activerecord-sqlserver-adapter 5.2.0 → 6.0.1

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     class SQLServerColumn < Column
-
-      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment = nil, sqlserver_options = {})
-        @sqlserver_options = sqlserver_options || {}
-        super(name, default, sql_type_metadata, null, table_name, default_function, collation, comment: comment)
+      def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil, **sqlserver_options)
+        @sqlserver_options = sqlserver_options
+        super
       end
 
       def is_identity?
@@ -15,6 +16,10 @@ module ActiveRecord
         @sqlserver_options[:is_primary]
       end
 
+      def table_name
+        @sqlserver_options[:table_name]
+      end
+
       def is_utf8?
         sql_type =~ /nvarchar|ntext|nchar/i
       end
@@ -22,7 +27,6 @@ module ActiveRecord
       def case_sensitive?
         collation && collation.match(/_CS/)
       end
-
     end
   end
 end

data/lib/active_record/sqlserver_base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionHandling
     def sqlserver_connection(config) #:nodoc:
@@ -6,11 +8,17 @@ module ActiveRecord
       mode = config[:mode].to_s.downcase.underscore.to_sym
       case mode
       when :dblib
-        require 'tiny_tds'
+        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
     end
   end
 end

data/lib/active_record/tasks/sqlserver_database_tasks.rb

@@ -1,14 +1,14 @@
-require 'active_record/tasks/database_tasks'
-require 'shellwords'
-require 'ipaddr'
-require 'socket'
+# frozen_string_literal: true
+
+require "active_record/tasks/database_tasks"
+require "shellwords"
+require "ipaddr"
+require "socket"
 
 module ActiveRecord
   module Tasks
-
     class SQLServerDatabaseTasks
-
-      DEFAULT_COLLATION = 'SQL_Latin1_General_CP1_CI_AS'
+      DEFAULT_COLLATION = "SQL_Latin1_General_CP1_CI_AS"
 
       delegate :connection, :establish_connection, :clear_active_connections!,
                to: ActiveRecord::Base
@@ -19,10 +19,10 @@ module ActiveRecord
 
       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.merge("collation" => default_collation)
         establish_connection configuration
-      rescue ActiveRecord::StatementInvalid => error
-        if /database .* already exists/i === error.message
+      rescue ActiveRecord::StatementInvalid => e
+        if /database .* already exists/i === e.message
           raise DatabaseAlreadyExists
         else
           raise
@@ -31,7 +31,7 @@ module ActiveRecord
 
       def drop
         establish_master_connection
-        connection.drop_database configuration['database']
+        connection.drop_database configuration["database"]
       end
 
       def charset
@@ -50,7 +50,7 @@ module ActiveRecord
 
       def structure_dump(filename, extra_flags)
         server_arg = "-S #{Shellwords.escape(configuration['host'])}"
-        server_arg += ":#{Shellwords.escape(configuration['port'])}" if configuration['port']
+        server_arg += ":#{Shellwords.escape(configuration['port'])}" if configuration["port"]
         command = [
           "defncopy-ttds",
           server_arg,
@@ -63,13 +63,14 @@ module ActiveRecord
         command.concat(table_args)
         view_args = connection.views.map { |v| Shellwords.escape(v) }
         command.concat(view_args)
-        raise 'Error dumping database' unless Kernel.system(command.join(' '))
+        raise "Error dumping database" unless Kernel.system(command.join(" "))
+
         dump = File.read(filename)
-        dump.gsub!(/^USE .*$\nGO\n/, '')                      # Strip db USE statements
-        dump.gsub!(/^GO\n/, '')                               # Strip db GO statements
-        dump.gsub!(/nvarchar\(8000\)/, 'nvarchar(4000)')      # Fix nvarchar(8000) column defs
-        dump.gsub!(/nvarchar\(-1\)/, 'nvarchar(max)')         # Fix nvarchar(-1) column defs
-        dump.gsub!(/text\(\d+\)/, 'text')                     # Fix text(16) column defs
+        dump.gsub!(/^USE .*$\nGO\n/, "")                      # Strip db USE statements
+        dump.gsub!(/^GO\n/, "")                               # Strip db GO statements
+        dump.gsub!(/nvarchar\(8000\)/, "nvarchar(4000)")      # Fix nvarchar(8000) column defs
+        dump.gsub!(/nvarchar\(-1\)/, "nvarchar(max)")         # Fix nvarchar(-1) column defs
+        dump.gsub!(/text\(\d+\)/, "text")                     # Fix text(16) column defs
         File.open(filename, "w") { |file| file.puts dump }
       end
 
@@ -77,7 +78,6 @@ module ActiveRecord
         connection.execute File.read(filename)
       end
 
-
       private
 
       def configuration
@@ -85,25 +85,22 @@ module ActiveRecord
       end
 
       def default_collation
-        configuration['collation'] || DEFAULT_COLLATION
+        configuration["collation"] || DEFAULT_COLLATION
       end
 
       def establish_master_connection
-        establish_connection configuration.merge('database' => 'master')
+        establish_connection configuration.merge("database" => "master")
       end
-
     end
 
     module DatabaseTasksSQLServer
-
       extend ActiveSupport::Concern
 
       module ClassMethods
-
         LOCAL_IPADDR = [
-          IPAddr.new('192.168.0.0/16'),
-          IPAddr.new('10.0.0.0/8'),
-          IPAddr.new('172.16.0.0/12')
+          IPAddr.new("192.168.0.0/16"),
+          IPAddr.new("10.0.0.0/8"),
+          IPAddr.new("172.16.0.0/12")
         ]
 
         private
@@ -113,21 +110,20 @@ module ActiveRecord
         end
 
         def configuration_host_ip(configuration)
-          return nil unless configuration['host']
-          Socket::getaddrinfo(configuration['host'], 'echo', Socket::AF_INET)[0][3]
+          return nil unless configuration["host"]
+
+          Socket::getaddrinfo(configuration["host"], "echo", Socket::AF_INET)[0][3]
         end
 
         def local_ipaddr?(host_ip)
           return false unless host_ip
+
           LOCAL_IPADDR.any? { |ip| ip.include?(host_ip) }
         end
-
       end
-
     end
 
     DatabaseTasks.register_task %r{sqlserver}, SQLServerDatabaseTasks
     DatabaseTasks.send :include, DatabaseTasksSQLServer
-
   end
 end

data/lib/activerecord-sqlserver-adapter.rb

@@ -1 +1,3 @@
-require 'active_record/connection_adapters/sqlserver_adapter'
+# frozen_string_literal: true
+
+require "active_record/connection_adapters/sqlserver_adapter"

data/lib/arel/visitors/sqlserver.rb

@@ -1,20 +1,20 @@
+# frozen_string_literal: true
+
 module Arel
   module Visitors
     class SQLServer < Arel::Visitors::ToSql
-
       OFFSET = " OFFSET "
       ROWS = " ROWS"
       FETCH = " FETCH NEXT "
       FETCH0 = " FETCH FIRST (SELECT 0) "
       ROWS_ONLY = " ROWS ONLY"
 
-
       private
 
       # SQLServer ToSql/Visitor (Overides)
 
       def visit_Arel_Nodes_BindParam o, collector
-        collector.add_bind(o.value) { |i| "@#{i-1}" }
+        collector.add_bind(o.value) { |i| "@#{i - 1}" }
       end
 
       def visit_Arel_Nodes_Bin o, collector
@@ -22,6 +22,12 @@ module Arel
         collector << " #{ActiveRecord::ConnectionAdapters::SQLServerAdapter.cs_equality_operator} "
       end
 
+      def visit_Arel_Nodes_Concat(o, collector)
+        visit o.left, collector
+        collector << " + "
+        visit o.right, collector
+      end
+
       def visit_Arel_Nodes_UpdateStatement(o, a)
         if o.orders.any? && o.limit.nil?
           o.limit = Nodes::Limit.new(9_223_372_036_854_775_807)
@@ -30,8 +36,8 @@ module Arel
       end
 
       def visit_Arel_Nodes_Lock o, collector
-        o.expr = Arel.sql('WITH(UPDLOCK)') if o.expr.to_s =~ /FOR UPDATE/
-        collector << SPACE
+        o.expr = Arel.sql("WITH(UPDLOCK)") if o.expr.to_s =~ /FOR UPDATE/
+        collector << " "
         visit o.expr, collector
       end
 
@@ -52,14 +58,19 @@ module Arel
         end
       end
 
+      def visit_Arel_Nodes_Grouping(o, collector)
+        remove_invalid_ordering_from_select_statement(o.expr)
+        super
+      end
+
       def visit_Arel_Nodes_SelectStatement o, collector
         @select_statement = o
         distinct_One_As_One_Is_So_Not_Fetch o
         if o.with
           collector = visit o.with, collector
-          collector << SPACE
+          collector << " "
         end
-        collector = o.cores.inject(collector) { |c,x|
+        collector = o.cores.inject(collector) { |c, x|
           visit_Arel_Nodes_SelectCore(x, c)
         }
         collector = visit_Orders_And_Let_Fetch_Happen o, collector
@@ -73,15 +84,17 @@ module Arel
         # 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
+        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)
+            end
+          rescue Exception
             quote_table_name(o.name)
           end
-        rescue Exception => e
-          quote_table_name(o.name)
-        end
+
         if o.table_alias
           collector << "#{table_name} #{quote_table_name o.table_alias}"
         else
@@ -95,8 +108,8 @@ module Arel
           collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector
         end
         if o.right.any?
-          collector << SPACE if o.left
-          collector = inject_join o.right, collector, ' '
+          collector << " " if o.left
+          collector = inject_join o.right, collector, " "
         end
         collector
       end
@@ -106,7 +119,7 @@ module Arel
         collector = visit o.left, collector
         collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
         if o.right
-          collector << SPACE
+          collector << " "
           visit(o.right, collector)
         else
           collector
@@ -117,16 +130,26 @@ module Arel
         collector << "LEFT OUTER JOIN "
         collector = visit o.left, collector
         collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
-        collector << SPACE
+        collector << " "
         visit o.right, collector
       end
 
+      def collect_in_clause(left, right, collector)
+        if Array === right
+          right.each { |node| remove_invalid_ordering_from_select_statement(node) }
+        else
+          remove_invalid_ordering_from_select_statement(right)
+        end
+
+        super
+      end
+
       # SQLServer ToSql/Visitor (Additions)
 
       def visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, options = {}
         if select_statement_lock?
           collector = visit @select_statement.lock, collector
-          collector << SPACE if options[:space]
+          collector << " " if options[:space]
         end
         collector
       end
@@ -134,12 +157,11 @@ module Arel
       def visit_Orders_And_Let_Fetch_Happen o, collector
         make_Fetch_Possible_And_Deterministic o
         unless o.orders.empty?
-          collector << SPACE
-          collector << ORDER_BY
+          collector << " ORDER BY "
           len = o.orders.length - 1
           o.orders.each_with_index { |x, i|
             collector = visit(x, collector)
-            collector << COMMA unless len == i
+            collector << ", " unless len == i
           }
         end
         collector
@@ -156,6 +178,7 @@ module Arel
 
       def node_value(node)
         return nil unless node
+
         case node.expr
         when NilClass then nil
         when Numeric then node.expr
@@ -169,9 +192,11 @@ module Arel
 
       def make_Fetch_Possible_And_Deterministic o
         return if o.limit.nil? && o.offset.nil?
+
         t = table_From_Statement o
         pk = primary_Key_From_Table t
         return unless pk
+
         if o.orders.empty?
           # Prefer deterministic vs a simple `(SELECT NULL)` expr.
           o.orders = [pk.asc]
@@ -196,14 +221,15 @@ module Arel
         elsif Arel::Nodes::SqlLiteral === core.from
           Arel::Table.new(core.from)
         elsif Arel::Nodes::JoinSource === core.source
-          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left
+          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left.left
         end
       end
 
       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
 
@@ -213,6 +239,14 @@ module Arel
         ).quoted
       end
 
+      # Need to remove ordering from subqueries unless TOP/OFFSET also used. Otherwise, SQLServer
+      # returns error "The ORDER BY clause is invalid in views, inline functions, derived tables,
+      # subqueries, and common table expressions, unless TOP, OFFSET or FOR XML is also specified."
+      def remove_invalid_ordering_from_select_statement(node)
+        return unless Arel::Nodes::SelectStatement === node
+
+        node.orders = [] unless node.offset || node.limit
+      end
     end
   end
 end

data/lib/arel_sqlserver.rb

@@ -1,2 +1,4 @@
-require 'arel'
-require 'arel/visitors/sqlserver'
+# frozen_string_literal: true
+
+require "arel"
+require "arel/visitors/sqlserver"

data/test/appveyor/dbsetup.ps1

@@ -5,15 +5,15 @@ Write-Output "Setting up..."
 
 Write-Output "Setting variables..."
 $serverName = $env:COMPUTERNAME
-$instances = @('SQL2012SP1', 'SQL2014')
+$instanceNames = @('SQL2014')
 $smo = 'Microsoft.SqlServer.Management.Smo.'
 $wmi = new-object ($smo + 'Wmi.ManagedComputer')
 
 Write-Output "Configure Instances..."
-foreach ($instance in $instances) {
-  Write-Output "Instance $instance ..."
+foreach ($instanceName in $instanceNames) {
+  Write-Output "Instance $instanceName ..."
   Write-Output "Enable TCP/IP and port 1433..."
-  $uri = "ManagedComputer[@Name='$serverName']/ServerInstance[@Name='$instance']/ServerProtocol[@Name='Tcp']"
+  $uri = "ManagedComputer[@Name='$serverName']/ServerInstance[@Name='$instanceName']/ServerProtocol[@Name='Tcp']"
   $tcp = $wmi.GetSmoObject($uri)
   $tcp.IsEnabled = $true
   foreach ($ipAddress in $Tcp.IPAddresses) {

data/test/cases/adapter_test_sqlserver.rb

@@ -1,72 +1,91 @@
-require 'cases/helper_sqlserver'
-require 'models/topic'
-require 'models/task'
-require 'models/post'
-require 'models/subscriber'
-require 'models/minimalistic'
+# frozen_string_literal: true
 
-class AdapterTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
+require "models/topic"
+require "models/task"
+require "models/post"
+require "models/subscriber"
+require "models/minimalistic"
 
+class AdapterTestSQLServer < ActiveRecord::TestCase
   fixtures :tasks
 
   let(:basic_insert_sql) { "INSERT INTO [funny_jokes] ([name]) VALUES('Knock knock')" }
   let(:basic_update_sql) { "UPDATE [customers] SET [address_street] = NULL WHERE [id] = 2" }
   let(:basic_select_sql) { "SELECT * FROM [customers] WHERE ([customers].[id] = 1)" }
 
-  it 'has basic and non-senstive information in the adpaters inspect method' do
+  it "has basic and non-sensitive information in the adapters inspect method" do
     string = connection.inspect
-    string.must_match %r{ActiveRecord::ConnectionAdapters::SQLServerAdapter}
-    string.must_match %r{version\: \d.\d}
-    string.must_match %r{mode: dblib}
-    string.must_match %r{azure: (true|false)}
-    string.wont_match %r{host}
-    string.wont_match %r{password}
-    string.wont_match %r{username}
-    string.wont_match %r{port}
+    _(string).must_match %r{ActiveRecord::ConnectionAdapters::SQLServerAdapter}
+    _(string).must_match %r{version\: \d.\d}
+    _(string).must_match %r{mode: dblib}
+    _(string).must_match %r{azure: (true|false)}
+    _(string).wont_match %r{host}
+    _(string).wont_match %r{password}
+    _(string).wont_match %r{username}
+    _(string).wont_match %r{port}
   end
 
-  it 'has a 128 max #table_alias_length' do
+  it "has a 128 max #table_alias_length" do
     assert connection.table_alias_length <= 128
   end
 
-  it 'raises invalid statement error for bad SQL' do
+  it "raises invalid statement error for bad SQL" do
     assert_raise(ActiveRecord::StatementInvalid) { Topic.connection.update("UPDATE XXX") }
   end
 
-  it 'is has our adapter_name' do
-    assert_equal 'SQLServer', connection.adapter_name
+  it "is has our adapter_name" do
+    assert_equal "SQLServer", connection.adapter_name
   end
 
-  it 'support DDL in transactions' do
+  it "support DDL in transactions" do
     assert connection.supports_ddl_transactions?
   end
 
-  it 'allow owner table name prefixs like dbo to still allow table exists to return true' do
+  it "allow owner table name prefixs like dbo to still allow table exists to return true" do
     begin
-      assert_equal 'topics', Topic.table_name
+      assert_equal "topics", Topic.table_name
       assert Topic.table_exists?
-      Topic.table_name = 'dbo.topics'
-      assert Topic.table_exists?, 'Tasks table name of dbo.topics should return true for exists.'
+      Topic.table_name = "dbo.topics"
+      assert Topic.table_exists?, "Tasks table name of dbo.topics should return true for exists."
     ensure
-      Topic.table_name = 'topics'
+      Topic.table_name = "topics"
     end
   end
 
-  it 'return true to insert sql query for inserts only' do
-    assert connection.send(:insert_sql?,'INSERT...')
+  it "return true to insert sql query for inserts only" do
+    assert connection.send(:insert_sql?, "INSERT...")
     assert connection.send(:insert_sql?, "EXEC sp_executesql N'INSERT INTO [fk_test_has_fks] ([fk_id]) VALUES (@0); SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident', N'@0 int', @0 = 0")
-    assert !connection.send(:insert_sql?,'UPDATE...')
-    assert !connection.send(:insert_sql?,'SELECT...')
+    assert !connection.send(:insert_sql?, "UPDATE...")
+    assert !connection.send(:insert_sql?, "SELECT...")
+  end
+
+  it "return unquoted table name object from basic INSERT UPDATE and SELECT statements" do
+    assert_equal "funny_jokes", connection.send(:get_table_name, basic_insert_sql)
+    assert_equal "customers", connection.send(:get_table_name, basic_update_sql)
+    assert_equal "customers", connection.send(:get_table_name, basic_select_sql)
   end
 
-  it 'return unquoted table name object from basic INSERT UPDATE and SELECT statements' do
-    assert_equal 'funny_jokes', connection.send(:get_table_name, basic_insert_sql)
-    assert_equal 'customers', connection.send(:get_table_name, basic_update_sql)
-    assert_equal 'customers', connection.send(:get_table_name, basic_select_sql)
+  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
+    end
   end
 
-  describe 'with different language' do
+  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),
+               "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"
+  end
+
+  describe "with different language" do
     before do
       @default_language = connection.user_options_language
     end
@@ -76,18 +95,18 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       connection.send :initialize_dateformatter
     end
 
-    it 'memos users dateformat' do
+    it "memos users dateformat" do
       connection.execute("SET LANGUAGE us_english") rescue nil
       dateformat = connection.instance_variable_get(:@database_dateformat)
-      assert_equal 'mdy', dateformat
+      assert_equal "mdy", dateformat
     end
 
-    it 'has a dateformatter' do
+    it "has a dateformatter" do
       assert Date::DATE_FORMATS[:_sqlserver_dateformat]
       assert Time::DATE_FORMATS[:_sqlserver_dateformat]
     end
 
-    it 'does a datetime insertion when language is german' do
+    it "does a datetime insertion when language is german" do
       connection.execute("SET LANGUAGE deutsch")
       connection.send :initialize_dateformatter
       assert_nothing_raised do
@@ -96,40 +115,36 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
         Task.create! starting: starting, ending: ending
       end
     end
-
   end
 
-  describe 'testing #lowercase_schema_reflection' do
-
+  describe "testing #lowercase_schema_reflection" do
     before do
       SSTestUpper.delete_all
-      SSTestUpper.create COLUMN1: 'Got a minute?', COLUMN2: 419
-      SSTestUpper.create COLUMN1: 'Favorite number?', COLUMN2: 69
+      SSTestUpper.create COLUMN1: "Got a minute?", COLUMN2: 419
+      SSTestUpper.create COLUMN1: "Favorite number?", COLUMN2: 69
     end
 
     after do
       connection.lowercase_schema_reflection = false
     end
 
-    it 'not lowercase schema reflection by default' do
-      assert SSTestUpper.columns_hash['COLUMN1']
-      assert_equal 'Got a minute?', SSTestUpper.first.COLUMN1
-      assert_equal 'Favorite number?', SSTestUpper.last.COLUMN1
-      assert SSTestUpper.columns_hash['COLUMN2']
+    it "not lowercase schema reflection by default" do
+      assert SSTestUpper.columns_hash["COLUMN1"]
+      assert_equal "Got a minute?", SSTestUpper.first.COLUMN1
+      assert_equal "Favorite number?", SSTestUpper.last.COLUMN1
+      assert SSTestUpper.columns_hash["COLUMN2"]
     end
 
-    it 'lowercase schema reflection when set' do
+    it "lowercase schema reflection when set" do
       connection.lowercase_schema_reflection = true
-      assert SSTestUppered.columns_hash['column1']
-      assert_equal 'Got a minute?', SSTestUppered.first.column1
-      assert_equal 'Favorite number?', SSTestUppered.last.column1
-      assert SSTestUppered.columns_hash['column2']
+      assert SSTestUppered.columns_hash["column1"]
+      assert_equal "Got a minute?", SSTestUppered.first.column1
+      assert_equal "Favorite number?", SSTestUppered.last.column1
+      assert SSTestUppered.columns_hash["column2"]
     end
-
   end
 
-  describe 'identity inserts' do
-
+  describe "identity inserts" do
     before do
       @identity_insert_sql = "INSERT INTO [funny_jokes] ([id],[name]) VALUES(420,'Knock knock')"
       @identity_insert_sql_unquoted = "INSERT INTO funny_jokes (id, name) VALUES(420, 'Knock knock')"
@@ -139,62 +154,60 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       @identity_insert_sql_unordered_sp = "EXEC sp_executesql N'INSERT INTO [funny_jokes] ([name],[id]) VALUES (@0, @1)', N'@0 nvarchar(255), @1  int', @0 = N'Knock knock', @1 = 420"
     end
 
-    it 'return quoted table_name to #query_requires_identity_insert? when INSERT sql contains id column' do
-      assert_equal 'funny_jokes', connection.send(:query_requires_identity_insert?,@identity_insert_sql)
-      assert_equal 'funny_jokes', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unquoted)
-      assert_equal 'funny_jokes', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unordered)
-      assert_equal 'funny_jokes', connection.send(:query_requires_identity_insert?,@identity_insert_sql_sp)
-      assert_equal 'funny_jokes', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unquoted_sp)
-      assert_equal 'funny_jokes', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unordered_sp)
+    it "return quoted table_name to #query_requires_identity_insert? when INSERT sql contains id column" do
+      assert_equal "funny_jokes", connection.send(:query_requires_identity_insert?, @identity_insert_sql)
+      assert_equal "funny_jokes", connection.send(:query_requires_identity_insert?, @identity_insert_sql_unquoted)
+      assert_equal "funny_jokes", connection.send(:query_requires_identity_insert?, @identity_insert_sql_unordered)
+      assert_equal "funny_jokes", connection.send(:query_requires_identity_insert?, @identity_insert_sql_sp)
+      assert_equal "funny_jokes", connection.send(:query_requires_identity_insert?, @identity_insert_sql_unquoted_sp)
+      assert_equal "funny_jokes", connection.send(:query_requires_identity_insert?, @identity_insert_sql_unordered_sp)
     end
 
-    it 'return false to #query_requires_identity_insert? for normal SQL' do
+    it "return false to #query_requires_identity_insert? for normal SQL" do
       [basic_insert_sql, basic_update_sql, basic_select_sql].each do |sql|
-        assert !connection.send(:query_requires_identity_insert?,sql), "SQL was #{sql}"
+        assert !connection.send(:query_requires_identity_insert?, sql), "SQL was #{sql}"
       end
     end
 
-    it 'find identity column using #identity_columns' do
-      task_id_column = Task.columns_hash['id']
+    it "find identity column using #identity_columns" do
+      task_id_column = Task.columns_hash["id"]
       assert_equal task_id_column.name, connection.send(:identity_columns, Task.table_name).first.name
       assert_equal task_id_column.sql_type, connection.send(:identity_columns, Task.table_name).first.sql_type
     end
 
-    it 'return an empty array when calling #identity_columns for a table_name with no identity' do
-      connection.send(:identity_columns, Subscriber.table_name).must_equal []
+    it "return an empty array when calling #identity_columns for a table_name with no identity" do
+      _(connection.send(:identity_columns, Subscriber.table_name)).must_equal []
     end
-
   end
 
-  describe 'quoting' do
-
-    it 'return 1 for #quoted_true' do
-      assert_equal '1', connection.quoted_true
+  describe "quoting" do
+    it "return 1 for #quoted_true" do
+      assert_equal "1", connection.quoted_true
     end
 
-    it 'return 0 for #quoted_false' do
-      assert_equal '0', connection.quoted_false
+    it "return 0 for #quoted_false" do
+      assert_equal "0", connection.quoted_false
     end
 
-    it 'not escape backslash characters like abstract adapter' do
+    it "not escape backslash characters like abstract adapter" do
       string_with_backslashs = "\\n"
       assert_equal string_with_backslashs, connection.quote_string(string_with_backslashs)
     end
 
-    it 'quote column names with brackets' do
-      assert_equal '[foo]', connection.quote_column_name(:foo)
-      assert_equal '[foo]', connection.quote_column_name('foo')
-      assert_equal '[foo].[bar]', connection.quote_column_name('foo.bar')
+    it "quote column names with brackets" do
+      assert_equal "[foo]", connection.quote_column_name(:foo)
+      assert_equal "[foo]", connection.quote_column_name("foo")
+      assert_equal "[foo].[bar]", connection.quote_column_name("foo.bar")
     end
 
-    it 'not quote already quoted column names with brackets' do
-      assert_equal '[foo]', connection.quote_column_name('[foo]')
-      assert_equal '[foo].[bar]', connection.quote_column_name('[foo].[bar]')
+    it "not quote already quoted column names with brackets" do
+      assert_equal "[foo]", connection.quote_column_name("[foo]")
+      assert_equal "[foo].[bar]", connection.quote_column_name("[foo].[bar]")
     end
 
-    it 'quote table names like columns' do
-      assert_equal '[foo].[bar]', connection.quote_column_name('foo.bar')
-      assert_equal '[foo].[bar].[baz]', connection.quote_column_name('foo.bar.baz')
+    it "quote table names like columns" do
+      assert_equal "[foo].[bar]", connection.quote_column_name("foo.bar")
+      assert_equal "[foo].[bar].[baz]", connection.quote_column_name("foo.bar.baz")
     end
 
     it "surround string with national prefix" do
@@ -204,44 +217,40 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     it "escape all single quotes by repeating them" do
       assert_equal "N'''quotation''s'''", connection.quote("'quotation's'")
     end
-
   end
 
-  describe 'disabling referential integrity' do
-
+  describe "disabling referential integrity" do
     before do
       connection.disable_referential_integrity { SSTestHasPk.delete_all; SSTestHasFk.delete_all }
       @parent = SSTestHasPk.create!
       @member = SSTestHasFk.create!(fk_id: @parent.id)
     end
 
-    it 'NOT ALLOW by default the deletion of a referenced parent' do
-      SSTestHasPk.connection.disable_referential_integrity { }
+    it "NOT ALLOW by default the deletion of a referenced parent" do
+      SSTestHasPk.connection.disable_referential_integrity {}
       assert_raise(ActiveRecord::StatementInvalid) { @parent.destroy }
     end
 
-    it 'ALLOW deletion of referenced parent using #disable_referential_integrity block' do
+    it "ALLOW deletion of referenced parent using #disable_referential_integrity block" do
       SSTestHasPk.connection.disable_referential_integrity { @parent.destroy }
     end
 
-    it 'again NOT ALLOW deletion of referenced parent after #disable_referential_integrity block' do
+    it "again NOT ALLOW deletion of referenced parent after #disable_referential_integrity block" do
       assert_raise(ActiveRecord::StatementInvalid) do
-        SSTestHasPk.connection.disable_referential_integrity { }
+        SSTestHasPk.connection.disable_referential_integrity {}
         @parent.destroy
       end
     end
 
-    it 'not disable referential integrity for the same table twice' do
+    it "not disable referential integrity for the same table twice" do
       tables = SSTestHasPk.connection.tables_with_referential_integrity
       assert_equal tables.size, tables.uniq.size
     end
-
   end
 
-  describe 'database statements' do
-
+  describe "database statements" do
     it "run the database consistency checker useroptions command" do
-      skip 'on azure' if connection_sqlserver_azure?
+      skip "on azure" if connection_sqlserver_azure?
       keys = [:textsize, :language, :isolation_level, :dateformat]
       user_options = connection.user_options
       keys.each do |key|
@@ -251,183 +260,217 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it "return a underscored key hash with indifferent access of the results" do
-      skip 'on azure' if connection_sqlserver_azure?
+      skip "on azure" if connection_sqlserver_azure?
       user_options = connection.user_options
-      assert_equal 'read committed', user_options['isolation_level']
-      assert_equal 'read committed', user_options[:isolation_level]
+      assert_equal "read committed", user_options["isolation_level"]
+      assert_equal "read committed", user_options[:isolation_level]
     end
-
   end
 
-  describe 'schema statements' do
-
-    it 'create integers when no limit supplied' do
-      assert_equal 'integer', connection.type_to_sql(:integer)
+  describe "schema statements" do
+    it "create integers when no limit supplied" do
+      assert_equal "integer", connection.type_to_sql(:integer)
     end
 
-    it 'create integers when limit is 4' do
-      assert_equal 'integer', connection.type_to_sql(:integer, limit: 4)
+    it "create integers when limit is 4" do
+      assert_equal "integer", connection.type_to_sql(:integer, limit: 4)
     end
 
-    it 'create integers when limit is 3' do
-      assert_equal 'integer', connection.type_to_sql(:integer, limit: 3)
+    it "create integers when limit is 3" do
+      assert_equal "integer", connection.type_to_sql(:integer, limit: 3)
     end
 
-    it 'create smallints when limit is 2' do
-      assert_equal 'smallint', connection.type_to_sql(:integer, limit: 2)
+    it "create smallints when limit is 2" do
+      assert_equal "smallint", connection.type_to_sql(:integer, limit: 2)
     end
 
-    it 'create tinyints when limit is 1' do
-      assert_equal 'tinyint', connection.type_to_sql(:integer, limit: 1)
+    it "create tinyints when limit is 1" do
+      assert_equal "tinyint", connection.type_to_sql(:integer, limit: 1)
     end
 
-    it 'create bigints when limit is greateer than 4' do
-      assert_equal 'bigint', connection.type_to_sql(:integer, limit: 5)
-      assert_equal 'bigint', connection.type_to_sql(:integer, limit: 6)
-      assert_equal 'bigint', connection.type_to_sql(:integer, limit: 7)
-      assert_equal 'bigint', connection.type_to_sql(:integer, limit: 8)
+    it "create bigints when limit is greateer than 4" do
+      assert_equal "bigint", connection.type_to_sql(:integer, limit: 5)
+      assert_equal "bigint", connection.type_to_sql(:integer, limit: 6)
+      assert_equal "bigint", connection.type_to_sql(:integer, limit: 7)
+      assert_equal "bigint", connection.type_to_sql(:integer, limit: 8)
     end
 
-    it 'create floats when no limit supplied' do
-      assert_equal 'float', connection.type_to_sql(:float)
+    it "create floats when no limit supplied" do
+      assert_equal "float", connection.type_to_sql(:float)
     end
-
   end
 
-  describe 'views' do
-
+  describe "views" do
     # Using connection.views
 
-    it 'return an array' do
+    it "return an array" do
       assert_instance_of Array, connection.views
     end
 
-    it 'find SSTestCustomersView table name' do
-      connection.views.must_include 'sst_customers_view'
+    it "find SSTestCustomersView table name" do
+      _(connection.views).must_include "sst_customers_view"
     end
 
-    it 'work with dynamic finders' do
-      name = 'MetaSkills'
+    it "work with dynamic finders" do
+      name = "MetaSkills"
       customer = SSTestCustomersView.create! name: name
       assert_equal customer, SSTestCustomersView.find_by_name(name)
     end
 
-    it 'not contain system views' do
-      systables = ['sysconstraints','syssegments']
+    it "not contain system views" do
+      systables = ["sysconstraints", "syssegments"]
       systables.each do |systable|
         assert !connection.views.include?(systable), "This systable #{systable} should not be in the views array."
       end
     end
 
-    it 'allow the connection#view_information method to return meta data on the view' do
-      view_info = connection.send(:view_information,'sst_customers_view')
-      assert_equal('sst_customers_view', view_info['TABLE_NAME'])
-      assert_match(/CREATE VIEW sst_customers_view/, view_info['VIEW_DEFINITION'])
+    it "allow the connection#view_information method to return meta data on the view" do
+      view_info = connection.send(:view_information, "sst_customers_view")
+      assert_equal("sst_customers_view", view_info["TABLE_NAME"])
+      assert_match(/CREATE VIEW sst_customers_view/, view_info["VIEW_DEFINITION"])
     end
 
-    it 'allow the connection#view_table_name method to return true table_name for the view' do
-      assert_equal 'customers', connection.send(:view_table_name,'sst_customers_view')
-      assert_equal 'topics', connection.send(:view_table_name,'topics'), 'No view here, the same table name should come back.'
+    it "allow the connection#view_table_name method to return true table_name for the view" do
+      assert_equal "customers", connection.send(:view_table_name, "sst_customers_view")
+      assert_equal "topics", connection.send(:view_table_name, "topics"), "No view here, the same table name should come back."
     end
 
     # With same column names
 
-    it 'have matching column objects' do
-      columns = ['id','name','balance']
+    it "have matching column objects" do
+      columns = ["id", "name", "balance"]
       assert !SSTestCustomersView.columns.blank?
       assert_equal columns.size, SSTestCustomersView.columns.size
       columns.each do |colname|
         assert_instance_of ActiveRecord::ConnectionAdapters::SQLServerColumn,
-          SSTestCustomersView.columns_hash[colname],
-          "Column name #{colname.inspect} was not found in these columns #{SSTestCustomersView.columns.map(&:name).inspect}"
+                           SSTestCustomersView.columns_hash[colname],
+                           "Column name #{colname.inspect} was not found in these columns #{SSTestCustomersView.columns.map(&:name).inspect}"
       end
     end
 
-    it 'find identity column' do
-      SSTestCustomersView.primary_key.must_equal 'id'
-      connection.primary_key(SSTestCustomersView.table_name).must_equal 'id'
-      SSTestCustomersView.columns_hash['id'].must_be :is_identity?
+    it "find identity column" do
+      _(SSTestCustomersView.primary_key).must_equal "id"
+      _(connection.primary_key(SSTestCustomersView.table_name)).must_equal "id"
+      _(SSTestCustomersView.columns_hash["id"]).must_be :is_identity?
     end
 
-    it 'find default values' do
+    it "find default values" do
       assert_equal 0, SSTestCustomersView.new.balance
     end
 
-    it 'respond true to data_source_exists?' do
+    it "respond true to data_source_exists?" do
       assert SSTestCustomersView.connection.data_source_exists?(SSTestCustomersView.table_name)
     end
 
     # With aliased column names
 
-    it 'have matching column objects' do
-      columns = ['id','pretend_null']
+    it "have matching column objects" do
+      columns = ["id", "pretend_null"]
       assert !SSTestStringDefaultsView.columns.blank?
       assert_equal columns.size, SSTestStringDefaultsView.columns.size
       columns.each do |colname|
         assert_instance_of ActiveRecord::ConnectionAdapters::SQLServerColumn,
-          SSTestStringDefaultsView.columns_hash[colname],
-          "Column name #{colname.inspect} was not found in these columns #{SSTestStringDefaultsView.columns.map(&:name).inspect}"
+                           SSTestStringDefaultsView.columns_hash[colname],
+                           "Column name #{colname.inspect} was not found in these columns #{SSTestStringDefaultsView.columns.map(&:name).inspect}"
       end
     end
 
-    it 'find identity column' do
-      SSTestStringDefaultsView.primary_key.must_equal 'id'
-      connection.primary_key(SSTestStringDefaultsView.table_name).must_equal 'id'
-      SSTestStringDefaultsView.columns_hash['id'].must_be :is_identity?
+    it "find identity column" do
+      _(SSTestStringDefaultsView.primary_key).must_equal "id"
+      _(connection.primary_key(SSTestStringDefaultsView.table_name)).must_equal "id"
+      _(SSTestStringDefaultsView.columns_hash["id"]).must_be :is_identity?
     end
 
-    it 'find default values' do
-      assert_equal 'null', SSTestStringDefaultsView.new.pretend_null,
-        SSTestStringDefaultsView.columns_hash['pretend_null'].inspect
+    it "find default values" do
+      assert_equal "null", SSTestStringDefaultsView.new.pretend_null,
+                   SSTestStringDefaultsView.columns_hash["pretend_null"].inspect
     end
 
-    it 'respond true to data_source_exists?' do
+    it "respond true to data_source_exists?" do
       assert SSTestStringDefaultsView.connection.data_source_exists?(SSTestStringDefaultsView.table_name)
     end
 
     # That have more than 4000 chars for their defintion
 
-    it 'cope with null returned for the defintion' do
+    it "cope with null returned for the defintion" do
       assert_nothing_raised() { SSTestStringDefaultsBigView.columns }
     end
 
-    it 'using alternate view defintion still be able to find real default' do
-      assert_equal 'null', SSTestStringDefaultsBigView.new.pretend_null,
-        SSTestStringDefaultsBigView.columns_hash['pretend_null'].inspect
+    it "using alternate view defintion still be able to find real default" do
+      assert_equal "null", SSTestStringDefaultsBigView.new.pretend_null,
+                   SSTestStringDefaultsBigView.columns_hash["pretend_null"].inspect
     end
-
   end
 
-  describe 'database_prefix_remote_server?' do
-
+  describe "database_prefix_remote_server?" do
     after do
       connection_options.delete(:database_prefix)
     end
 
-    it 'returns false if database_prefix is not configured' do
+    it "returns false if database_prefix is not configured" do
       assert_equal false, connection.database_prefix_remote_server?
     end
 
-    it 'returns true if database_prefix has been set' do
+    it "returns true if database_prefix has been set" do
       connection_options[:database_prefix] = "server.database.schema."
       assert_equal true, connection.database_prefix_remote_server?
     end
 
-    it 'returns false if database_prefix has been set incorrectly' do
+    it "returns false if database_prefix has been set incorrectly" do
       connection_options[:database_prefix] = "server.database.schema"
       assert_equal false, connection.database_prefix_remote_server?
     end
-
   end
 
-  it 'in_memory_oltp' do
-    if ENV['IN_MEMORY_OLTP'] && connection.supports_in_memory_oltp?
-      SSTMemory.primary_key.must_equal 'id'
-      SSTMemory.columns_hash['id'].must_be :is_identity?
+  it "in_memory_oltp" do
+    if ENV["IN_MEMORY_OLTP"] && connection.supports_in_memory_oltp?
+      _(SSTMemory.primary_key).must_equal "id"
+      _(SSTMemory.columns_hash["id"]).must_be :is_identity?
     else
-      skip 'supports_in_memory_oltp? => false'
+      skip "supports_in_memory_oltp? => false"
     end
   end
 
-end
+  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
+          @conn.insert("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
+        end
+      end
+    end
+
+    def test_errors_when_an_update_query_is_called_while_preventing_writes
+      @conn.insert("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
+
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @connection_handler.while_preventing_writes do
+          @conn.update("UPDATE [subscribers] SET [subscribers].[name] = 'Aidan' WHERE [subscribers].[nick] = 'aido'")
+        end
+      end
+    end
+
+    def test_errors_when_a_delete_query_is_called_while_preventing_writes
+      @conn.execute("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
+
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @connection_handler.while_preventing_writes do
+          @conn.execute("DELETE FROM [subscribers] WHERE [subscribers].[nick] = 'aido'")
+        end
+      end
+    end
+
+    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
+        assert_equal 1, @conn.execute("SELECT * FROM [subscribers] WHERE [subscribers].[nick] = 'aido'")
+      end
+    end
+  end
+end