activerecord-sqlserver-adapter 3.1.3 → 3.1.4

data/CHANGELOG

@@ -1,4 +1,35 @@
 
+* 3.1.4 *
+
+* Use INFORMATION_SCHEMA.KEY_COLUMN_USAGE for schema reflection speed. 
+  Fixes #125. [Wüthrich Hannes @hwuethrich]
+
+* New deadlock victim retry using the #retry_deadlock_victim config.  [Joe Rafaniello]
+
+* Renamed #with_auto_reconnect to #with_sqlserver_error_handling now that it handles both dropped
+  connections and deadlock victim errors. Fixes #150 [Joe Rafaniello]
+
+* Add activity_stats method that mimics the SQL Server Activity Monitor. Fixes #146 [Joe Rafaniello]
+
+* Add methods for sqlserver's #product_version, #product_level, #edition and include them in inspect.
+  Fixes #145 [Joe Rafaniello]
+  
+* Handle statements that cannot be retried on a new database connection by not reconnecting. 
+  Fixes #147 [Joe Rafaniello]
+  
+* Added connection#spid for debugging. Fixes #144 [Joe Rafaniello]
+
+* Add ENV['TEST_FILES'] to Rakefile for easy single case tests. [Joe Rafaniello]
+
+* Pass ActiveRecord tests. Made windowed distinct pass all orders to groups.
+  - test_limited_eager_with_multiple_order_columns
+  - test_limited_eager_with_order
+
+* Pass AR tests by moving DISTINCT to GROUP BY in windowed SQL.
+  - test_count_eager_with_has_many_and_limit_and_high_offset
+  - test_eager_with_has_many_and_limit_and_high_offset
+
+
 * 3.1.3 *
 
 * Distinguish between identity and primary key key columns during schema reflection. Allows us 

data/lib/active_record/connection_adapters/sqlserver/core_ext/database_statements.rb

@@ -0,0 +1,97 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sqlserver
+      module CoreExt
+        module DatabaseStatements
+          
+          # This is a copy of the current (3.1.3) ActiveRecord's transaction method. We should propose
+          # a patch to the default transaction method to make it more callback for adapters that want to 
+          # do deadlock retry logic. Because this is a copy, we really need to keep an eye out on this when
+          # upgradding the adapter. 
+          def transaction_with_retry_deadlock_victim(options = {})
+            options.assert_valid_keys :requires_new, :joinable
+
+            last_transaction_joinable = defined?(@transaction_joinable) ? @transaction_joinable : nil
+            if options.has_key?(:joinable)
+              @transaction_joinable = options[:joinable]
+            else
+              @transaction_joinable = true
+            end
+            requires_new = options[:requires_new] || !last_transaction_joinable
+
+            transaction_open = false
+            @_current_transaction_records ||= []
+
+            begin
+              if block_given?
+                if requires_new || open_transactions == 0
+                  if open_transactions == 0
+                    begin_db_transaction
+                  elsif requires_new
+                    create_savepoint
+                  end
+                  increment_open_transactions
+                  transaction_open = true
+                  @_current_transaction_records.push([])
+                end
+                yield
+              end
+            rescue Exception => database_transaction_rollback
+              if transaction_open && !outside_transaction?
+                transaction_open = false
+                decrement_open_transactions
+                # handle deadlock victim retries at the outermost transaction
+                if open_transactions == 0
+                  if database_transaction_rollback.is_a?(::ActiveRecord::DeadlockVictim)
+                    # SQL Server has already rolled back, so rollback activerecord's history
+                    rollback_transaction_records(true)
+                    retry
+                  else
+                    rollback_db_transaction
+                    rollback_transaction_records(true)
+                  end
+                else
+                  rollback_to_savepoint
+                  rollback_transaction_records(false)
+                end
+              end
+              raise unless database_transaction_rollback.is_a?(::ActiveRecord::Rollback)
+            end
+          ensure
+            @transaction_joinable = last_transaction_joinable
+
+            if outside_transaction?
+              @open_transactions = 0
+            elsif transaction_open
+              decrement_open_transactions
+              begin
+                if open_transactions == 0
+                  commit_db_transaction
+                  commit_transaction_records
+                else
+                  release_savepoint
+                  save_point_records = @_current_transaction_records.pop
+                  unless save_point_records.blank?
+                    @_current_transaction_records.push([]) if @_current_transaction_records.empty?
+                    @_current_transaction_records.last.concat(save_point_records)
+                  end
+                end
+              rescue Exception => database_transaction_rollback
+                if open_transactions == 0
+                  rollback_db_transaction
+                  rollback_transaction_records(true)
+                else
+                  rollback_to_savepoint
+                  rollback_transaction_records(false)
+                end
+                raise
+              end
+            end
+          end
+          
+        end
+      end
+    end
+  end
+end
+

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

@@ -3,6 +3,8 @@ module ActiveRecord
     module Sqlserver
       module DatabaseStatements
         
+        include CoreExt::DatabaseStatements
+        
         def select_rows(sql, name = nil)
           raw_select sql, name, [], :fetch => :rows
         end
@@ -45,12 +47,20 @@ module ActiveRecord
           true
         end
 
+        def transaction(options = {})
+          if retry_deadlock_victim?
+            block_given? ? transaction_with_retry_deadlock_victim(options) { yield } : transaction_with_retry_deadlock_victim(options)
+          else
+            block_given? ? super(options) { yield } : super(options)
+          end
+        end
+
         def begin_db_transaction
           do_execute "BEGIN TRANSACTION"
         end
 
         def commit_db_transaction
-          do_execute "COMMIT TRANSACTION"
+          disable_auto_reconnect { do_execute "COMMIT TRANSACTION" }
         end
 
         def rollback_db_transaction
@@ -58,14 +68,14 @@ module ActiveRecord
         end
 
         def create_savepoint
-          do_execute "SAVE TRANSACTION #{current_savepoint_name}"
+          disable_auto_reconnect { do_execute "SAVE TRANSACTION #{current_savepoint_name}" }
         end
 
         def release_savepoint
         end
 
         def rollback_to_savepoint
-          do_execute "ROLLBACK TRANSACTION #{current_savepoint_name}"
+          disable_auto_reconnect { do_execute "ROLLBACK TRANSACTION #{current_savepoint_name}" }
         end
 
         def add_limit_offset!(sql, options)
@@ -185,6 +195,51 @@ module ActiveRecord
           select_value "SELECT NEWSEQUENTIALID()"
         end
         
+        def activity_stats
+          select_all %|
+            SELECT
+               [session_id]    = s.session_id,
+               [user_process]  = CONVERT(CHAR(1), s.is_user_process),
+               [login]         = s.login_name,
+               [database]      = ISNULL(db_name(r.database_id), N''),
+               [task_state]    = ISNULL(t.task_state, N''),
+               [command]       = ISNULL(r.command, N''),
+               [application]   = ISNULL(s.program_name, N''),
+               [wait_time_ms]  = ISNULL(w.wait_duration_ms, 0),
+               [wait_type]     = ISNULL(w.wait_type, N''),
+               [wait_resource] = ISNULL(w.resource_description, N''),
+               [blocked_by]    = ISNULL(CONVERT (varchar, w.blocking_session_id), ''),
+               [head_blocker]  =
+                    CASE
+                        -- session has an active request, is blocked, but is blocking others
+                        WHEN r2.session_id IS NOT NULL AND r.blocking_session_id = 0 THEN '1'
+                        -- session is idle but has an open tran and is blocking others
+                        WHEN r.session_id IS NULL THEN '1'
+                        ELSE ''
+                    END,
+               [total_cpu_ms]   = s.cpu_time,
+               [total_physical_io_mb]   = (s.reads + s.writes) * 8 / 1024,
+               [memory_use_kb]  = s.memory_usage * 8192 / 1024,
+               [open_transactions] = ISNULL(r.open_transaction_count,0),
+               [login_time]     = s.login_time,
+               [last_request_start_time] = s.last_request_start_time,
+               [host_name]      = ISNULL(s.host_name, N''),
+               [net_address]    = ISNULL(c.client_net_address, N''),
+               [execution_context_id] = ISNULL(t.exec_context_id, 0),
+               [request_id]     = ISNULL(r.request_id, 0),
+               [workload_group] = N''
+            FROM sys.dm_exec_sessions s LEFT OUTER JOIN sys.dm_exec_connections c ON (s.session_id = c.session_id)
+            LEFT OUTER JOIN sys.dm_exec_requests r ON (s.session_id = r.session_id)
+            LEFT OUTER JOIN sys.dm_os_tasks t ON (r.session_id = t.session_id AND r.request_id = t.request_id)
+            LEFT OUTER JOIN
+            (SELECT *, ROW_NUMBER() OVER (PARTITION BY waiting_task_address ORDER BY wait_duration_ms DESC) AS row_num
+                FROM sys.dm_os_waiting_tasks
+            ) w ON (t.task_address = w.waiting_task_address) AND w.row_num = 1
+            LEFT OUTER JOIN sys.dm_exec_requests r2 ON (r.session_id = r2.blocking_session_id)
+            WHERE db_name(r.database_id) = '#{current_database}'
+            ORDER BY s.session_id|
+        end
+        
         # === SQLServer Specific (Rake/Test Helpers) ==================== #
         
         def recreate_database
@@ -262,7 +317,7 @@ module ActiveRecord
         def do_execute(sql, name = nil)
           name ||= 'EXECUTE'
           log(sql, name) do
-            with_auto_reconnect { raw_connection_do(sql) }
+            with_sqlserver_error_handling { raw_connection_do(sql) }
           end
         end
         
@@ -307,18 +362,20 @@ module ActiveRecord
         # === SQLServer Specific (Selecting) ============================ #
 
         def raw_select(sql, name=nil, binds=[], options={})
-          log(sql,name,binds) do
-            begin
-              handle = raw_connection_run(sql)
-              handle_to_names_and_values(handle, options)
-            ensure
-              finish_statement_handle(handle)
-            end
+          log(sql,name,binds) { _raw_select(sql, options) }
+        end
+        
+        def _raw_select(sql, options={})
+          begin
+            handle = raw_connection_run(sql)
+            handle_to_names_and_values(handle, options)
+          ensure
+            finish_statement_handle(handle)
           end
         end
         
         def raw_connection_run(sql)
-          with_auto_reconnect do
+          with_sqlserver_error_handling do
             case @connection_options[:mode]
             when :dblib
               @connection.execute(sql)

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

@@ -3,6 +3,9 @@ module ActiveRecord
   class LostConnection < WrappedDatabaseException
   end
   
+  class DeadlockVictim < WrappedDatabaseException
+  end
+  
   module ConnectionAdapters
     module Sqlserver
       module Errors

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

@@ -193,7 +193,7 @@ module ActiveRecord
               ELSE NULL
             END AS [is_nullable],
             CASE 
-              WHEN CCU.COLUMN_NAME IS NOT NULL AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY' THEN 1
+              WHEN KCU.COLUMN_NAME IS NOT NULL AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY' THEN 1
               ELSE NULL
             END AS [is_primary],
             CASE 
@@ -201,12 +201,17 @@ module ActiveRecord
               ELSE NULL
             END AS [is_identity]
             FROM #{db_name_with_period}INFORMATION_SCHEMA.COLUMNS columns
-            LEFT OUTER JOIN #{db_name_with_period}INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC ON TC.TABLE_NAME = columns.TABLE_NAME AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY' 
-            LEFT OUTER JOIN #{db_name_with_period}INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE AS CCU ON TC.CONSTRAINT_NAME = CCU.CONSTRAINT_NAME AND CCU.COLUMN_NAME = columns.COLUMN_NAME
+            LEFT OUTER JOIN #{db_name_with_period}INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC 
+              ON TC.TABLE_NAME = columns.TABLE_NAME 
+              AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY' 
+            LEFT OUTER JOIN #{db_name_with_period}INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KCU
+              ON KCU.COLUMN_NAME = columns.COLUMN_NAME
+              AND KCU.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
+              AND KCU.CONSTRAINT_CATALOG = TC.CONSTRAINT_CATALOG
+              AND KCU.CONSTRAINT_SCHEMA = TC.CONSTRAINT_SCHEMA
             WHERE columns.TABLE_NAME = @0
               AND columns.TABLE_SCHEMA = #{table_schema.blank? ? "schema_name()" : "@1"}
             ORDER BY columns.ordinal_position
-            
           }.gsub(/[ \t\r\n]+/,' ')
           binds = [['table_name', table_name]]
           binds << ['table_schema',table_schema] unless table_schema.blank?

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

@@ -3,7 +3,7 @@ module ActiveRecord
     module Sqlserver
       module Version
         
-        VERSION = '3.1.3'.freeze
+        VERSION = '3.1.4'
         
       end
     end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -2,6 +2,7 @@ require 'arel/visitors/sqlserver'
 require 'active_record'
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_record/connection_adapters/sqlserver/core_ext/active_record'
+require 'active_record/connection_adapters/sqlserver/core_ext/database_statements'
 require 'active_record/connection_adapters/sqlserver/database_limits'
 require 'active_record/connection_adapters/sqlserver/database_statements'
 require 'active_record/connection_adapters/sqlserver/errors'
@@ -176,10 +177,10 @@ module ActiveRecord
       DATABASE_VERSION_REGEXP     = /Microsoft SQL Server\s+"?(\d{4}|\w+)"?/
       SUPPORTED_VERSIONS          = [2005,2008,2010,2011].freeze
       
-      attr_reader :database_version, :database_year
+      attr_reader :database_version, :database_year, :spid, :product_level, :product_version, :edition
       
       cattr_accessor :native_text_database_type, :native_binary_database_type, :native_string_database_type,
-                     :log_info_schema_queries, :enable_default_unicode_types, :auto_connect,
+                     :log_info_schema_queries, :enable_default_unicode_types, :auto_connect, :retry_deadlock_victim,
                      :cs_equality_operator, :lowercase_schema_reflection, :auto_connect_duration
       
       self.enable_default_unicode_types = true
@@ -208,6 +209,9 @@ module ActiveRecord
                          rescue
                            0
                          end
+        @product_level    = info_schema_query { select_value("SELECT CAST(SERVERPROPERTY('productlevel') AS VARCHAR(128))") }
+        @product_version  = info_schema_query { select_value("SELECT CAST(SERVERPROPERTY('productversion') AS VARCHAR(128))") }
+        @edition          = info_schema_query { select_value("SELECT CAST(SERVERPROPERTY('edition') AS VARCHAR(128))") }
         initialize_dateformatter
         initialize_sqlserver_caches
         use_database
@@ -269,6 +273,7 @@ module ActiveRecord
       end
 
       def disconnect!
+        @spid = nil
         case @connection_options[:mode]
         when :dblib
           @connection.close rescue nil
@@ -323,7 +328,7 @@ module ActiveRecord
       end
       
       def inspect
-        "#<#{self.class} version: #{version}, year: #{@database_year}, connection_options: #{@connection_options.inspect}>"
+        "#<#{self.class} version: #{version}, year: #{@database_year}, product_level: #{@product_level.inspect}, product_version: #{@product_version.inspect}, edition: #{@edition.inspect}, connection_options: #{@connection_options.inspect}>"
       end
       
       def auto_connect
@@ -334,6 +339,11 @@ module ActiveRecord
         @@auto_connect_duration ||= 10
       end
       
+      def retry_deadlock_victim
+        @@retry_deadlock_victim.is_a?(FalseClass) ? false : true
+      end
+      alias :retry_deadlock_victim? :retry_deadlock_victim
+      
       def native_string_database_type
         @@native_string_database_type || (enable_default_unicode_types ? 'nvarchar' : 'varchar') 
       end
@@ -358,7 +368,6 @@ module ActiveRecord
         @@cs_equality_operator || 'COLLATE Latin1_General_CS_AS_WS'
       end
       
-      
       protected
       
       # === Abstract Adapter (Misc Support) =========================== #
@@ -369,6 +378,8 @@ module ActiveRecord
           RecordNotUnique.new(message,e)
         when /conflicted with the foreign key constraint/i
           InvalidForeignKey.new(message,e)
+        when /has been chosen as the deadlock victim/i
+          DeadlockVictim.new(message,e)
         when *lost_connection_messages
           LostConnection.new(message,e)
         else
@@ -431,6 +442,7 @@ module ActiveRecord
                           end
                         end
                       end
+        @spid             = _raw_select("SELECT @@SPID", :fetch => :rows).first.first
         configure_connection
       rescue
         raise unless @auto_connecting
@@ -468,15 +480,25 @@ module ActiveRecord
         end if block_given?
       end
       
-      def with_auto_reconnect
+      def with_sqlserver_error_handling
         begin
           yield
         rescue Exception => e
-          retry if translate_exception(e,e.message).is_a?(LostConnection) && auto_reconnected?
+          case translate_exception(e,e.message)
+            when LostConnection; retry if auto_reconnected?
+            when DeadlockVictim; retry if retry_deadlock_victim? && open_transactions == 0
+          end
           raise
         end
       end
       
+      def disable_auto_reconnect
+        old_auto_connect, self.class.auto_connect = self.class.auto_connect, false
+        yield
+      ensure
+        self.class.auto_connect = old_auto_connect
+      end
+      
       def auto_reconnected?
         return false unless auto_connect
         @auto_connecting = true

data/lib/arel/visitors/sqlserver.rb

@@ -138,9 +138,11 @@ module Arel
         orders = o.orders.uniq
         if windowed
           projections = function_select_statement?(o) ? projections : projections.map { |x| projection_without_expression(x) }
+          groups = projections.map { |x| projection_without_expression(x) } if windowed_single_distinct_select_statement?(o) && groups.empty?
+          groups += orders.map { |x| Arel.sql(x.expr) } if windowed_single_distinct_select_statement?(o)
         elsif eager_limiting_select_statement?(o)
-          groups = projections.map { |x| projection_without_expression(x) }
           projections = projections.map { |x| projection_without_expression(x) }
+          groups = projections.map { |x| projection_without_expression(x) }
           orders = orders.map do |x|
             expr = Arel.sql projection_without_expression(x.expr)
             x.descending? ? Arel::Nodes::Max.new([expr]) : Arel::Nodes::Min.new([expr])
@@ -162,7 +164,7 @@ module Arel
       def visit_Arel_Nodes_SelectStatementWithOffset(o)
         orders = rowtable_orders(o)
         [ "SELECT",
-          (visit(o.limit) if o.limit && !single_distinct_select_statement?(o)),
+          (visit(o.limit) if o.limit && !windowed_single_distinct_select_statement?(o)),
           (rowtable_projections(o).map{ |x| visit(x) }.join(', ')),
           "FROM (",
             "SELECT ROW_NUMBER() OVER (ORDER BY #{orders.map{ |x| visit(x) }.join(', ')}) AS [__rn],",
@@ -238,6 +240,10 @@ module Arel
             p1.respond_to?(:include?) && p1.include?('DISTINCT'))
       end
       
+      def windowed_single_distinct_select_statement?(o)
+        o.limit && o.offset && single_distinct_select_statement?(o)
+      end
+      
       def single_distinct_select_everything_statement?(o)
         single_distinct_select_statement?(o) && visit(o.cores.first.projections.first).ends_with?(".*")
       end
@@ -316,7 +322,17 @@ module Arel
 
       def rowtable_projections(o)
         core = o.cores.first
-        if single_distinct_select_statement?(o)
+        if windowed_single_distinct_select_statement?(o) && core.groups.blank?
+          tn = table_from_select_statement(o).name
+          core.projections.map do |x|
+            x.dup.tap do |p|
+              p.sub! 'DISTINCT', ''
+              p.insert 0, visit(o.limit) if o.limit
+              p.gsub! /\[?#{tn}\]?\./, '[__rnt].'
+              p.strip!
+            end
+          end
+        elsif single_distinct_select_statement?(o)
           tn = table_from_select_statement(o).name
           core.projections.map do |x|
             x.dup.tap do |p|

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 11
   prerelease: 
   segments: 
   - 3
   - 1
-  - 3
-  version: 3.1.3
+  - 4
+  version: 3.1.4
 platform: ruby
 authors: 
 - Ken Collins
@@ -19,8 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-28 00:00:00 -04:00
-default_executable: 
+date: 2011-11-30 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -50,6 +49,7 @@ files:
 - CHANGELOG
 - MIT-LICENSE
 - lib/active_record/connection_adapters/sqlserver/core_ext/active_record.rb
+- lib/active_record/connection_adapters/sqlserver/core_ext/database_statements.rb
 - lib/active_record/connection_adapters/sqlserver/core_ext/odbc.rb
 - lib/active_record/connection_adapters/sqlserver/database_limits.rb
 - lib/active_record/connection_adapters/sqlserver/database_statements.rb
@@ -60,7 +60,6 @@ files:
 - lib/active_record/connection_adapters/sqlserver_adapter.rb
 - lib/activerecord-sqlserver-adapter.rb
 - lib/arel/visitors/sqlserver.rb
-has_rdoc: true
 homepage: http://github.com/rails-sqlserver/activerecord-sqlserver-adapter
 licenses: []
 
@@ -90,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: activerecord-sqlserver-adapter
-rubygems_version: 1.6.2
+rubygems_version: 1.8.8
 signing_key: 
 specification_version: 3
 summary: SQL Server 2005 and 2008 Adapter For ActiveRecord.