Better add_lock! method that can add the lock to just about all the elements in the statement. This could be eager loaded associations, joins, etc. Done so that paginated results can easily add lock options for performance. Note, the tally count in add_limit_offset! use "WITH (NOLOCK)" explicitly as it can not hurt and is needed.

Author: metaskills

CHANGELOG

@@ -1,7 +1,10 @@
 
 MASTER
 
-* 
+* Better add_lock! method that can add the lock to just about all the elements in the statement. This 
+  could be eager loaded associations, joins, etc. Done so that paginated results can easily add lock 
+  options for performance. Note, the tally count in add_limit_offset! use "WITH (NOLOCK)" explicitly 
+  as it can not hurt and is needed. [Ken Collins]
 
 
 * 2.2.14 * (March 17th, 2009)

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -394,7 +394,9 @@ def add_limit_offset!(sql, options)
         end
         # The business of adding limit/offset
         if options[:limit] and options[:offset]
-          total_rows = select_value("SELECT count(*) as TotalRows from (#{sql.sub(/\bSELECT(\s+DISTINCT)?\b/i, "SELECT#{$1} TOP 1000000000")}) tally").to_i
+          tally_sql = "SELECT count(*) as TotalRows from (#{sql.sub(/\bSELECT(\s+DISTINCT)?\b/i, "SELECT#{$1} TOP 1000000000")}) tally"
+          add_lock! tally_sql, :lock => 'WITH (NOLOCK)'
+          total_rows = select_value(tally_sql).to_i
           if (options[:limit] + options[:offset]) >= total_rows
             options[:limit] = (total_rows - options[:offset] >= 0) ? (total_rows - options[:offset]) : 0
           end
@@ -439,8 +441,8 @@ def add_lock!(sql, options)
         # http://blog.sqlauthority.com/2007/04/27/sql-server-2005-locking-hints-and-examples/
         return unless options[:lock]
         lock_type = options[:lock] == true ? 'WITH(HOLDLOCK, ROWLOCK)' : options[:lock]
-        from_table = sql.match(/FROM(.*)WHERE/im)[1]
-        sql.sub! from_table, "#{from_table}#{lock_type} "
+        sql.gsub! %r|LEFT OUTER JOIN\s+(.*?)\s+ON|im, "LEFT OUTER JOIN \\1 #{lock_type} ON"
+        sql.gsub! %r{FROM\s([\w\[\]\.]+)}im, "FROM \\1 #{lock_type}"
       end
 
       def empty_insert_statement(table_name)

test/cases/pessimistic_locking_test_sqlserver.rb

@@ -49,9 +49,34 @@ def setup
         end
       end
     end
+    
+    should 'simply add lock to find all' do
+      assert_sql %r|SELECT \* FROM \[people\] WITH \(NOLOCK\)| do
+        Person.all(:lock => 'WITH (NOLOCK)')
+      end
+    end
+
+  end
+  
+  context 'For paginated finds' do
+    
+    setup do
+      20.times { |n| Person.create!(:first_name => "Thing_#{n}") }
+    end
+    
+    should 'cope with un-locked paginated results' do
+      tally_not_locked = %r|SELECT count\(\*\) as TotalRows from \(SELECT TOP 1000000000 \* FROM \[people\]\s+WITH \(NOLOCK\) \) tally|
+      inner_tmp_not_locked = %r|SELECT TOP 15 \* FROM \[people\] WITH \(NOLOCK\)|
+      # Currently association limiting is not locked like the parent.
+      association_limiting_not_locked = %r|SELECT \[readers\]\.\* FROM \[readers\] WITH \(NOLOCK\) WHERE \(\[readers\]\.person_id IN \(1,2,3,4,5\)\)|
+      assert_sql(tally_not_locked,inner_tmp_not_locked) do
+        Person.all(:include => :readers, :lock => 'WITH (NOLOCK)', :limit => 5, :offset => 10)
+      end
+    end
 
   end
 
+  
   context 'For dueling concurrent connections' do
 
     use_concurrent_connections

test/cases/sqlserver_helper.rb

@@ -78,7 +78,8 @@ def method_added(method)
 # Our changes/additions to ActiveRecord test helpers specific for SQL Server.
 
 ActiveRecord::Base.connection.class.class_eval do
-  IGNORED_SQL << /SELECT SCOPE_IDENTITY/ << /INFORMATION_SCHEMA.TABLES/ << /INFORMATION_SCHEMA.COLUMNS/ << /^SELECT @@TRANCOUNT/  
+  IGNORED_SQL << %r|SELECT SCOPE_IDENTITY| << %r{INFORMATION_SCHEMA\.(TABLES|VIEWS|COLUMNS)}
+  IGNORED_SQL << %r|SELECT @@IDENTITY| << %r|SELECT @@ROWCOUNT| << %r|SELECT @@version| << %r|SELECT @@TRANCOUNT|
 end
 
 ActiveRecord::ConnectionAdapters::SQLServerAdapter.class_eval do