Use ActiveRecord tranasaction interface vs our own run_with_isolation_level.

Author: metaskills

CHANGELOG.md

@@ -19,6 +19,7 @@
 * Follow Rails convention and remove varying character default limits.
 * The `cs_equality_operator` is now s class configuration property only.
 * The `with_identity_insert_enabled(table_name)` is now public.
+* Use ActiveRecord tranasaction interface vs our own `run_with_isolation_level`.
 
 #### Deprecated
 

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -52,6 +52,20 @@ def begin_db_transaction
           do_execute 'BEGIN TRANSACTION'
         end
 
+        def transaction_isolation_levels
+          super.merge snapshot: "SNAPSHOT"
+        end
+
+        def begin_isolated_db_transaction(isolation)
+          set_transaction_isolation_level transaction_isolation_levels.fetch(isolation)
+          begin_db_transaction
+        end
+
+        def set_transaction_isolation_level(isolation_level)
+          do_execute "SET TRANSACTION ISOLATION LEVEL #{isolation_level}"
+          begin_db_transaction
+        end
+
         def commit_db_transaction
           do_execute 'COMMIT TRANSACTION'
         end
@@ -175,19 +189,6 @@ def user_options_language
           end
         end
 
-        def run_with_isolation_level(isolation_level)
-          unless valid_isolation_levels.include?(isolation_level.upcase)
-            raise ArgumentError, "Invalid isolation level, #{isolation_level}. Supported levels include #{valid_isolation_levels.to_sentence}."
-          end
-          initial_isolation_level = user_options_isolation_level || 'READ COMMITTED'
-          do_execute "SET TRANSACTION ISOLATION LEVEL #{isolation_level}"
-          begin
-            yield
-          ensure
-            do_execute "SET TRANSACTION ISOLATION LEVEL #{initial_isolation_level}"
-          end if block_given?
-        end
-
         def newid_function
           select_value 'SELECT NEWID()'
         end
@@ -300,10 +301,6 @@ def set_identity_insert(table_name, enable = true)
           raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
         end
 
-        def valid_isolation_levels
-          ['READ COMMITTED', 'READ UNCOMMITTED', 'REPEATABLE READ', 'SERIALIZABLE', 'SNAPSHOT']
-        end
-
         # === SQLServer Specific (Executing) ============================ #
 
         def do_execute(sql, name = 'SQL')

lib/active_record/connection_adapters/sqlserver/transaction.rb

@@ -0,0 +1,52 @@
+require 'active_record/connection_adapters/abstract/transaction'
+
+module ActiveRecord
+  module ConnectionAdapters
+
+    module SQLServerTransaction
+
+      private
+
+      def sqlserver?
+        connection.respond_to?(:sqlserver?) && connection.sqlserver?
+      end
+
+      def current_isolation_level
+        return unless sqlserver?
+        level = connection.user_options_isolation_level
+        level.blank? ? 'READ COMMITTED' : level.upcase
+      end
+
+    end
+
+    Transaction.include SQLServerTransaction
+
+    module SQLServerRealTransaction
+
+      attr_reader :starting_isolation_level
+
+      def initialize(connection, options)
+        @connection = connection
+        @starting_isolation_level = current_isolation_level if options[:isolation]
+        super
+      end
+
+      def commit
+        super
+        reset_starting_isolation_level
+      end
+
+      private
+
+      def reset_starting_isolation_level
+        if sqlserver? && starting_isolation_level
+          connection.set_transaction_isolation_level(starting_isolation_level)
+        end
+      end
+
+    end
+
+    RealTransaction.include SQLServerRealTransaction
+
+  end
+end

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -10,6 +10,7 @@
 require 'active_record/connection_adapters/sqlserver/type'
 require 'active_record/connection_adapters/sqlserver/database_limits'
 require 'active_record/connection_adapters/sqlserver/database_statements'
+require 'active_record/connection_adapters/sqlserver/transaction'
 require 'active_record/connection_adapters/sqlserver/errors'
 require 'active_record/connection_adapters/sqlserver/schema_cache'
 require 'active_record/connection_adapters/sqlserver/schema_creation'
@@ -102,6 +103,10 @@ def supports_explain?
         true
       end
 
+      def supports_transaction_isolation?
+        true
+      end
+
       def disable_referential_integrity
         do_execute "EXEC sp_MSforeachtable 'ALTER TABLE ? NOCHECK CONSTRAINT ALL'"
         yield

test/cases/adapter_test_sqlserver.rb

@@ -254,56 +254,6 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert_equal 'read committed', user_options[:isolation_level]
     end
 
-    describe '#run_with_isolation_level' do
-
-      let(:task1) { tasks(:first_task) }
-      let(:task2) { tasks(:another_task) }
-
-      before do
-        assert task1, 'Tasks :first_task should be in AR fixtures'
-        assert task2, 'Tasks :another_task should be in AR fixtures'
-        good_isolation_level = connection.user_options_isolation_level.blank? || connection.user_options_isolation_level =~ /read committed/i
-        assert good_isolation_level, "User isolation level is not at a happy starting place: #{connection.user_options_isolation_level.inspect}"
-      end
-
-      it "barf if the requested isolation level is not valid" do
-        assert_raise(ArgumentError) do
-          connection.run_with_isolation_level 'INVALID ISOLATION LEVEL' do; end
-        end
-      end
-
-      it 'allow #run_with_isolation_level to not take a block to set it' do
-        begin
-          connection.run_with_isolation_level 'READ UNCOMMITTED'
-          assert_match %r|read uncommitted|i, connection.user_options_isolation_level
-        ensure
-          connection.run_with_isolation_level 'READ COMMITTED'
-        end
-      end
-
-      it 'return block value using #run_with_isolation_level' do
-        assert_equal Task.all.sort, connection.run_with_isolation_level('READ UNCOMMITTED') { Task.all.sort }
-      end
-
-      it 'pass a read uncommitted isolation level test' do
-        assert_nil task2.starting, 'Fixture should have this empty.'
-        begin
-          Task.transaction do
-            task2.starting = Time.now
-            task2.save
-            @dirty_t2 = connection.run_with_isolation_level('READ UNCOMMITTED') { Task.find(task2.id) }
-            raise ActiveRecord::ActiveRecordError
-          end
-        rescue
-          'Do Nothing'
-        end
-        assert @dirty_t2, 'Should have a Task record from within block above.'
-        assert @dirty_t2.starting, 'Should have a dirty date.'
-        assert_nil Task.find(task2.id).starting, 'Should be nil again from botched transaction above.'
-      end
-
-    end
-
   end
 
   describe 'schema statements' do

test/cases/coerced_tests.rb

@@ -331,6 +331,29 @@ def self.search(term)
 
 
 
+
+class TransactionIsolationTest < ActiveRecord::TestCase
+
+  # SQL Server will lock the table for counts even when both
+  # connections are `READ COMMITTED`. So we bypass with `READPAST`.
+  coerce_tests! %r{read committed}
+  test "read committed coerced" do
+    Tag.transaction(isolation: :read_committed) do
+      assert_equal 0, Tag.count
+      Tag2.transaction do
+        Tag2.create
+        assert_equal 0, Tag.lock('WITH(READPAST)').count
+      end
+    end
+    assert_equal 1, Tag.count
+  end
+
+  # I really need some help understanding this one.
+  coerce_tests! %r{repeatable read}
+
+end
+
+
 require 'models/post'
 module ActiveRecord
   class WhereChainTest < ActiveRecord::TestCase

test/cases/transaction_test_sqlserver.rb

@@ -30,6 +30,23 @@ class TransactionTestSQLServer < ActiveRecord::TestCase
     end
   end
 
+  it 'can use an isolation level and reverts back to starting isolation level' do
+    begin
+      in_level = nil
+      begin_level = connection.user_options_isolation_level
+      begin_level.must_match %r{read committed}
+      Ship.transaction(isolation: :serializable) do
+        Ship.create! name: 'Black Pearl'
+        in_level = connection.user_options_isolation_level
+      end
+      after_level = connection.user_options_isolation_level
+      in_level.must_match %r{serializable}i
+      after_level.must_match %r{read committed}
+    ensure
+      connection.set_transaction_isolation_level 'READ COMMITTED'
+    end
+  end
+
 
   protected