rails-sqlserver-2000-2005-adapter 2.2.15 → 2.2.16

data/CHANGELOG

@@ -1,7 +1,25 @@
 
 MASTER
 
-* 
+*
+
+
+* 2.2.16 * (April 21st, 2009)
+
+* Make add_limit_offset! only add locking hints (for tally) when the :lock option is present. Added tests 
+  to make sure tally SQL is augmented correctly and tests to make sure that add_lock! is doing what it needs 
+  for deep sub selects in paginated results. [Ken Collins]
+
+* Add auto reconnect support utilizing a new #with_auto_reconnect block. By default each query run through 
+  the adapter will automatically reconnect at standard intervals, logging attempts along the way, till success 
+  or the original exception bubbles up. See docs for more details. Resolves ticket #18 [Ken Collins] 
+
+* Update internal helper method #orders_and_dirs_set to cope with an order clause like "description desc". This 
+  resolves ticket #26 [Ken Collins]
+
+* Provide support for running queries at different isolation levels using #run_with_isolation_level method 
+  that can take a block or not. Also implement a #user_options method that reflects on the current user 
+  session values. Resolves #20 [Murray Steele]
 
 
 * 2.2.15 * (March 23rd, 2009)

data/README.rdoc

@@ -16,6 +16,8 @@ The SQL Server adapter for rails is back for ActiveRecord 2.2 and up! We are cur
 * Enabled #case_sensitive_equality_operator used by unique validations.
 * Unicode character support for nchar, nvarchar and ntext data types. Configuration option for defaulting all string data types to the unicode safe types.
 * View support for table names, identity inserts, and column defaults.
+* A block method to run queries within a specific isolation level.
+* Automatically reconnects to lost database connections.
 
 ==== Date/Time Data Type Hinting
 
@@ -103,6 +105,12 @@ By default all queries to the INFORMATION_SCHEMA table is silenced. If you think
 
   ActiveRecord::ConnectionAdapters::SQLServerAdapter.log_info_schema_queries = true
 
+==== Auto Connecting
+
+By default the adapter will auto connect to lost DB connections. For every query it will retry at intervals of 2, 4, 8, 16 and 32 seconds. During each retry it will callback out to ActiveRecord::Base.did_retry_sqlserver_connection(connection,count). When all retries fail, it will callback to ActiveRecord::Base.did_lose_sqlserver_connection(connection). Both implementations of these methods are to write to the rails logger, however, they make great override points for notifications like Hoptoad. If you want to disable automatic reconnections use the following in an initializer.
+
+  ActiveRecord::ConnectionAdapters::SQLServerAdapter.auto_connect = false
+
 
 == Versions
 

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -23,9 +23,17 @@ module ActiveRecord
         host      = config[:host] ? config[:host].to_s : 'localhost'
         driver_url = "DBI:ADO:Provider=SQLOLEDB;Data Source=#{host};Initial Catalog=#{database};User ID=#{username};Password=#{password};"
       end
-      conn = DBI.connect(driver_url, username, password)
-      conn["AutoCommit"] = true
-      ConnectionAdapters::SQLServerAdapter.new(conn, logger, [driver_url, username, password])
+      ConnectionAdapters::SQLServerAdapter.new(logger, [driver_url, username, password])
+    end
+    
+    protected
+    
+    def self.did_retry_sqlserver_connection(connection,count)
+      logger.info "CONNECTION RETRY: #{connection.class.name} retry ##{count}."
+    end
+    
+    def self.did_lose_sqlserver_connection(connection)
+      logger.info "CONNECTION LOST: #{connection.class.name}"
     end
     
   end
@@ -150,13 +158,20 @@ module ActiveRecord
     class SQLServerAdapter < AbstractAdapter
       
       ADAPTER_NAME            = 'SQLServer'.freeze
-      VERSION                 = '2.2.15'.freeze
+      VERSION                 = '2.2.16'.freeze
       DATABASE_VERSION_REGEXP = /Microsoft SQL Server\s+(\d{4})/
       SUPPORTED_VERSIONS      = [2000,2005].freeze
       LIMITABLE_TYPES         = ['string','integer','float','char','nchar','varchar','nvarchar'].freeze
       
+      LOST_CONNECTION_EXCEPTIONS = [DBI::DatabaseError, DBI::InterfaceError]
+      LOST_CONNECTION_MESSAGES = [
+        'Communication link failure',
+        'Read from the server failed',
+        'Write to the server failed',
+        'Database connection was already closed']
+      
       cattr_accessor :native_text_database_type, :native_binary_database_type, :native_string_database_type,
-                     :log_info_schema_queries, :enable_default_unicode_types
+                     :log_info_schema_queries, :enable_default_unicode_types, :auto_connect
       
       class << self
         
@@ -166,9 +181,10 @@ module ActiveRecord
         
       end
       
-      def initialize(connection, logger, connection_options=nil)
-        super(connection, logger)
+      def initialize(logger, connection_options)
         @connection_options = connection_options
+        connect
+        super(raw_connection, logger)
         initialize_sqlserver_caches
         unless SUPPORTED_VERSIONS.include?(database_year)
           raise NotImplementedError, "Currently, only #{SUPPORTED_VERSIONS.to_sentence} are supported."
@@ -221,6 +237,10 @@ module ActiveRecord
         "#<#{self.class} version: #{version}, year: #{database_year}, connection_options: #{@connection_options.inspect}>"
       end
       
+      def auto_connect
+        @@auto_connect.is_a?(FalseClass) ? false : true
+      end
+      
       def native_string_database_type
         @@native_string_database_type || (enable_default_unicode_types ? 'nvarchar' : 'varchar') 
       end
@@ -302,16 +322,14 @@ module ActiveRecord
       def active?
         raw_connection.execute("SELECT 1").finish
         true
-      rescue DBI::DatabaseError, DBI::InterfaceError
+      rescue *LOST_CONNECTION_EXCEPTIONS
         false
       end
 
       def reconnect!
         disconnect!
-        @connection = DBI.connect(*@connection_options)
-      rescue DBI::DatabaseError => e
-        @logger.warn "#{adapter_name} reconnection failed: #{e.message}" if @logger
-        false
+        connect
+        active?
       end
 
       def disconnect!
@@ -325,6 +343,30 @@ module ActiveRecord
       
       # DATABASE STATEMENTS ======================================#
       
+      def user_options
+        info_schema_query do
+          select_rows("dbcc useroptions").inject(HashWithIndifferentAccess.new) do |values,row| 
+            set_option = row[0].gsub(/\s+/,'_')
+            user_value = row[1]
+            values[set_option] = user_value
+            values
+          end
+        end
+      end
+      
+      VALID_ISOLATION_LEVELS = ["READ COMMITTED", "READ UNCOMMITTED", "REPEATABLE READ", "SERIALIZABLE", "SNAPSHOT"]
+      
+      def run_with_isolation_level(isolation_level)
+        raise ArgumentError, "Invalid isolation level, #{isolation_level}. Supported levels include #{VALID_ISOLATION_LEVELS.to_sentence}." if !VALID_ISOLATION_LEVELS.include?(isolation_level.upcase)
+        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 select_rows(sql, name = nil)
         raw_select(sql,name).last
       end
@@ -395,7 +437,7 @@ module ActiveRecord
         # The business of adding limit/offset
         if options[:limit] and options[:offset]
           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)'
+          add_lock! tally_sql, options
           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
@@ -697,6 +739,47 @@ module ActiveRecord
       
       protected
       
+      # CONNECTION MANAGEMENT ====================================#
+      
+      def connect
+        driver_url, username, password = @connection_options
+        @connection = DBI.connect(driver_url, username, password)
+        configure_connection
+      rescue
+        raise unless @auto_connecting
+      end
+      
+      def configure_connection
+        raw_connection['AutoCommit'] = true
+      end
+      
+      def with_auto_reconnect
+        begin
+          yield
+        rescue *LOST_CONNECTION_EXCEPTIONS => e
+          if LOST_CONNECTION_MESSAGES.any? { |lcm| e.message =~ Regexp.new(lcm,Regexp::IGNORECASE) }
+            retry if auto_reconnected?
+          end
+          raise
+        end
+      end
+      
+      def auto_reconnected?
+        return false unless auto_connect
+        @auto_connecting = true
+        count = 0
+        while count <= 5
+          sleep 2** count
+          ActiveRecord::Base.did_retry_sqlserver_connection(self,count)
+          return true if reconnect!
+          count += 1
+        end
+        ActiveRecord::Base.did_lose_sqlserver_connection(self)
+        false
+      ensure
+        @auto_connecting = false
+      end
+      
       # DATABASE STATEMENTS ======================================
       
       def select(sql, name = nil, ignore_special_columns = false)
@@ -727,9 +810,9 @@ module ActiveRecord
       def raw_execute(sql, name = nil, &block)
         log(sql, name) do
           if block_given?
-            raw_connection.execute(sql) { |handle| yield(handle) }
+            with_auto_reconnect { raw_connection.execute(sql) { |handle| yield(handle) } }
           else
-            raw_connection.execute(sql)
+            with_auto_reconnect { raw_connection.execute(sql) }
           end
         end
       end
@@ -743,7 +826,7 @@ module ActiveRecord
       
       def do_execute(sql,name=nil)
         log(sql, name || 'EXECUTE') do
-          raw_connection.do(sql)
+          with_auto_reconnect { raw_connection.do(sql) }
         end
       end
       
@@ -877,12 +960,13 @@ module ActiveRecord
         orders = order.sub('ORDER BY','').split(',').map(&:strip).reject(&:blank?)
         orders_dirs = orders.map do |ord|
           dir = nil
-          if match_data = ord.match(/\b(asc|desc)$/i)
-            dir = match_data[1]
-            ord.sub!(dir,'').strip!
-            dir.upcase!
+          ord.sub!(/\b(asc|desc)$/i) do |match|
+            if match
+              dir = match.upcase.strip
+              ''
+            end
           end
-          [ord,dir]
+          [ord.strip, dir]
         end
       end
       

data/test/cases/adapter_test_sqlserver.rb

@@ -5,6 +5,8 @@ require 'models/joke'
 require 'models/subscriber'
 
 class AdapterTestSqlserver < ActiveRecord::TestCase
+  
+  fixtures :tasks
     
   def setup
     @connection = ActiveRecord::Base.connection
@@ -376,6 +378,78 @@ class AdapterTestSqlserver < ActiveRecord::TestCase
   
   context 'For DatabaseStatements' do
     
+    context "finding out what user_options are available" do
+      
+      should "run the database consistency checker useroptions command" do
+        @connection.expects(:select_rows).with(regexp_matches(/^dbcc\s+useroptions$/i)).returns []
+        @connection.user_options
+      end
+      
+      should "return a underscored key hash with indifferent access of the results" do
+        @connection.expects(:select_rows).with(regexp_matches(/^dbcc\s+useroptions$/i)).returns [['some', 'thing'], ['isolation level', 'read uncommitted']]
+        uo = @connection.user_options
+        assert_equal 2, uo.keys.size
+        assert_equal 'thing', uo['some']
+        assert_equal 'thing', uo[:some]
+        assert_equal 'read uncommitted', uo['isolation_level']
+        assert_equal 'read uncommitted', uo[:isolation_level]
+      end
+      
+    end
+
+    context "altering isolation levels" do
+      
+      should "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
+      
+      context "with a valid isolation level" do
+        
+        setup do
+          @t1 = tasks(:first_task)
+          @t2 = tasks(:another_task)
+          assert @t1, 'Tasks :first_task should be in AR fixtures'
+          assert @t2, '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
+        
+        should '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
+        
+        should 'return block value using #run_with_isolation_level' do
+          assert_same_elements Task.find(:all), @connection.run_with_isolation_level('READ UNCOMMITTED') { Task.find(:all) }
+        end
+        
+        should 'pass a read uncommitted isolation level test' do
+          assert_nil @t2.starting, 'Fixture should have this empty.'
+          begin
+            Task.transaction do
+              @t2.starting = Time.now
+              @t2.save
+              @dirty_t2 = @connection.run_with_isolation_level('READ UNCOMMITTED') { Task.find(@t2.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(@t2.id).starting, 'Should be nil again from botched transaction above.'
+        end unless active_record_2_point_2? # Transactions in tests are a bit screwy in 2.2.
+        
+      end
+      
+    end
+    
   end
   
   context 'For SchemaStatements' do

data/test/cases/connection_test_sqlserver.rb

@@ -78,6 +78,37 @@ class ConnectionTestSqlserver < ActiveRecord::TestCase
     end
   end
   
+  context 'Connection management' do
+    
+    setup do
+      assert @connection.active?
+    end
+    
+    should 'be able to disconnect and reconnect at will' do
+      @connection.disconnect!
+      assert !@connection.active?
+      @connection.reconnect!
+      assert @connection.active?
+    end
+    
+    should 'auto reconnect when setting is on' do
+      with_auto_connect(true) do
+        @connection.disconnect!
+        assert_nothing_raised() { Topic.count }
+        assert @connection.active?
+      end
+    end
+    
+    should 'not auto reconnect when setting is off' do
+      with_auto_connect(false) do
+        @connection.disconnect!
+        assert_raise(ActiveRecord::StatementInvalid) { Topic.count }
+      end
+    end
+    
+  end
+  
+  
   
   private
   
@@ -99,5 +130,13 @@ class ConnectionTestSqlserver < ActiveRecord::TestCase
   ensure
     GC.enable
   end
+  
+  def with_auto_connect(boolean)
+    existing = ActiveRecord::ConnectionAdapters::SQLServerAdapter.auto_connect
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.auto_connect = boolean
+    yield
+  ensure
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.auto_connect = existing
+  end
 
 end

data/test/cases/offset_and_limit_test_sqlserver.rb

@@ -66,9 +66,16 @@ class OffsetAndLimitTestSqlserver < ActiveRecord::TestCase
 
     should 'alter SQL to limit number of records returned offset by specified amount' do
       options = { :limit => 3, :offset => 5 }
-      expected_sql = %&SELECT * FROM (SELECT TOP 3 * FROM (SELECT TOP 8 * FROM books) AS tmp1) AS tmp2&
+      expected_sql = "SELECT * FROM (SELECT TOP 3 * FROM (SELECT TOP 8 * FROM books) AS tmp1) AS tmp2"
       assert_equal(expected_sql, @connection.add_limit_offset!(@select_sql, options))
     end
+    
+    should 'add locks to deepest sub select in limit offset sql that has a limited tally' do
+      options = { :limit => 3, :offset => 5, :lock => 'WITH (NOLOCK)' }
+      expected_sql = "SELECT * FROM (SELECT TOP 3 * FROM (SELECT TOP 8 * FROM books WITH (NOLOCK)) AS tmp1) AS tmp2"
+      @connection.add_limit_offset! @select_sql, options
+      assert_equal expected_sql, @connection.add_lock!(@select_sql,options)
+    end
 
     # Not really sure what an offset sql injection might look like
     should 'not allow sql injection via offset' do
@@ -82,6 +89,18 @@ class OffsetAndLimitTestSqlserver < ActiveRecord::TestCase
       assert_equal expected_sql, @connection.add_limit_offset!(@subquery_select_sql,options)
     end
     
+    should 'add lock hints to tally sql if :lock option is present' do
+      assert_sql %r|SELECT TOP 1000000000 \* FROM \[people\] WITH \(NOLOCK\)| do
+        Person.all :limit => 5, :offset => 1, :lock => 'WITH (NOLOCK)'
+      end
+    end
+    
+    should 'not add lock hints to tally sql if there is no :lock option' do
+      assert_sql %r|\(SELECT TOP 1000000000 \* FROM \[people\] \)| do
+        Person.all :limit => 5, :offset => 1
+      end
+    end
+    
   end
   
   

data/test/cases/specific_schema_test_sqlserver.rb

@@ -1,6 +1,7 @@
 require 'cases/sqlserver_helper'
 
 class StringDefault < ActiveRecord::Base; end;
+class SqlServerEdgeSchema < ActiveRecord::Base; end;
 
 class SpecificSchemaTestSqlserver < ActiveRecord::TestCase
   
@@ -23,4 +24,34 @@ class SpecificSchemaTestSqlserver < ActiveRecord::TestCase
     assert_equal '(NULL)', default.string_with_pretend_null_four
   end
   
+  context 'Testing edge case schemas' do
+    
+    setup do
+      @edge_class = SqlServerEdgeSchema
+    end
+    
+    context 'with description column' do
+
+      setup do
+        @da = @edge_class.create! :description => 'A'
+        @db = @edge_class.create! :description => 'B'
+        @dc = @edge_class.create! :description => 'C'
+      end
+      
+      teardown { @edge_class.delete_all }
+
+      should 'allow all sorts of ordering without adapter munging it up' do
+        assert_equal ['A','B','C'], @edge_class.all(:order => 'description').map(&:description)
+        assert_equal ['A','B','C'], @edge_class.all(:order => 'description asc').map(&:description)
+        assert_equal ['A','B','C'], @edge_class.all(:order => 'description ASC').map(&:description)
+        assert_equal ['C','B','A'], @edge_class.all(:order => 'description desc').map(&:description)
+        assert_equal ['C','B','A'], @edge_class.all(:order => 'description DESC').map(&:description)
+      end
+
+    end
+    
+
+  end
+  
+  
 end

data/test/schema/sqlserver_specific_schema.rb

@@ -63,6 +63,10 @@ ActiveRecord::Schema.define do
     # TODO: Add some different native binary types and test.
   end
   
+  create_table :sql_server_edge_schemas, :force => true do |t|
+    t.string :description
+  end
+  
   execute "IF EXISTS (SELECT TABLE_NAME FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = 'customers_view') DROP VIEW customers_view"
   execute <<-CUSTOMERSVIEW
     CREATE VIEW customers_view AS

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rails-sqlserver-2000-2005-adapter
 version: !ruby/object:Gem::Version 
-  version: 2.2.15
+  version: 2.2.16
 platform: ruby
 authors: 
 - Ken Collins
@@ -13,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-23 00:00:00 -07:00
+date: 2009-04-21 00:00:00 -07:00
 default_executable: 
 dependencies: []