activerecord-sqlserver-adapter 3.1.1 → 3.2.18

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

@@ -0,0 +1,26 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sqlserver
+      module CoreExt
+        class ExplainSubscriber
+          def call(*args)
+            if queries = Thread.current[:available_queries_for_explain]
+              payload = args.last
+              queries << payload.values_at(:sql, :binds) unless ignore_sqlserver_payload?(payload)
+            end
+          end
+
+          IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN CACHE)
+          SQLSERVER_EXPLAINED_SQLS = /(select|update|delete|insert)/i
+
+          # Need to modify the regex for the TSQL generated by this adapter so we can explain the proper sql statements
+          def ignore_sqlserver_payload?(payload)
+            payload[:exception] || IGNORED_PAYLOADS.include?(payload[:name]) || payload[:sql] !~ SQLSERVER_EXPLAINED_SQLS
+          end
+
+          ActiveSupport::Notifications.subscribe("sql.active_record", new)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sqlserver
+      module CoreExt
+        module Relation
+          
+          private
+          
+          def tables_in_string(string)
+            super - ['__rnt']
+          end
+          
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.send :include, ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::Relation

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

@@ -2,7 +2,9 @@ module ActiveRecord
   module ConnectionAdapters
     module Sqlserver
       module DatabaseStatements
-        
+
+        include CoreExt::DatabaseStatements
+
         def select_rows(sql, name = nil)
           raw_select sql, name, [], :fetch => :rows
         end
@@ -14,7 +16,7 @@ module ActiveRecord
             do_execute(sql,name)
           end
         end
-        
+
         def exec_query(sql, name = 'SQL', binds = [], sqlserver_options = {})
           if id_insert_table_name = sqlserver_options[:insert] ? query_requires_identity_insert?(sql) : nil
             with_identity_insert_enabled(id_insert_table_name) { do_exec_query(sql, name, binds) }
@@ -22,11 +24,11 @@ module ActiveRecord
             do_exec_query(sql, name, binds)
           end
         end
-        
+
         def exec_insert(sql, name, binds)
           exec_query sql, name, binds, :insert => true
         end
-        
+
         def exec_delete(sql, name, binds)
           sql << "; SELECT @@ROWCOUNT AS AffectedRows"
           super.rows.first.first
@@ -38,34 +40,42 @@ module ActiveRecord
         end
 
         def outside_transaction?
-          info_schema_query { select_value("SELECT @@TRANCOUNT") == 0 }
+          uncached { select_value('SELECT @@TRANCOUNT', 'SCHEMA') == 0 }
         end
-        
+
         def supports_statement_cache?
           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
-          do_execute "ROLLBACK TRANSACTION" rescue nil
+          do_execute "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION"
         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)
@@ -79,11 +89,15 @@ module ActiveRecord
         def case_sensitive_modifier(node)
           node.acts_like?(:string) ? Arel::Nodes::Bin.new(node) : node
         end
-        
+
         # === SQLServer Specific ======================================== #
-        
+
         def execute_procedure(proc_name, *variables)
-          vars = variables.map{ |v| quote(v) }.join(', ')
+          vars = if variables.any? && variables.first.is_a?(Hash)
+                   variables.first.map { |k,v| "@#{k} = #{quote(v)}" }
+                 else
+                   variables.map { |v| quote(v) }
+                 end.join(', ')
           sql = "EXEC #{proc_name} #{vars}".strip
           name = 'Execute Procedure'
           log(sql, name) do
@@ -112,45 +126,130 @@ module ActiveRecord
             end
           end
         end
-        
+
         def use_database(database=nil)
           return if sqlserver_azure?
           database ||= @connection_options[:database]
           do_execute "USE #{quote_table_name(database)}" unless database.blank?
         end
-        
+
         def user_options
-          info_schema_query do
-            select_rows("dbcc useroptions").inject(HashWithIndifferentAccess.new) do |values,row| 
-              set_option = row[0].gsub(/\s+/,'_')
+          return {} if sqlserver_azure?
+          # fixes #535
+          rows = select_rows('DBCC USEROPTIONS WITH NO_INFOMSGS', 'SCHEMA')
+          rows = rows.first if rows.size == 2 && rows.last.empty?
+          rows.reduce(HashWithIndifferentAccess.new) do |values, row|
+            if row.instance_of? Hash
+              set_option = row.values[0].gsub(/\s+/, '_')
+              user_value = row.values[1]
+            elsif  row.instance_of? Array
+              set_option = row[0].gsub(/\s+/, '_')
               user_value = row[1]
-              values[set_option] = user_value
-              values
             end
+            values[set_option] = user_value
+            values
+          end
+        end
+
+        def user_options_dateformat
+          if sqlserver_azure?
+            select_value 'SELECT [dateformat] FROM [sys].[syslanguages] WHERE [langid] = @@LANGID', 'SCHEMA'
+          else
+            user_options['dateformat']
+          end
+        end
+
+        def user_options_isolation_level
+          if sqlserver_azure?
+            sql = %|SELECT CASE [transaction_isolation_level]
+                    WHEN 0 THEN NULL
+                    WHEN 1 THEN 'READ UNCOMITTED'
+                    WHEN 2 THEN 'READ COMITTED'
+                    WHEN 3 THEN 'REPEATABLE READ'
+                    WHEN 4 THEN 'SERIALIZABLE'
+                    WHEN 5 THEN 'SNAPSHOT' END AS [isolation_level]
+                    FROM [sys].[dm_exec_sessions]
+                    WHERE [session_id] = @@SPID|.squish
+            select_value sql, 'SCHEMA'
+          else
+            user_options['isolation_level']
+          end
+        end
+
+        def user_options_language
+          if sqlserver_azure?
+            select_value 'SELECT @@LANGUAGE AS [language]', 'SCHEMA'
+          else
+            user_options['language']
           end
         end
 
         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"
+          initial_isolation_level = user_options_isolation_level || "READ COMMITTED"
           do_execute "SET TRANSACTION ISOLATION LEVEL #{isolation_level}"
           begin
-            yield 
+            yield
           ensure
             do_execute "SET TRANSACTION ISOLATION LEVEL #{initial_isolation_level}"
           end if block_given?
         end
-        
+
         def newid_function
           select_value "SELECT NEWID()"
         end
-        
+
         def newsequentialid_function
           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
           remove_database_connections_and_rollback do
             do_execute "EXEC sp_MSforeachtable 'DROP TABLE ?'"
@@ -194,18 +293,18 @@ module ActiveRecord
         def current_database
           select_value 'SELECT DB_NAME()'
         end
-        
+
         def charset
           select_value "SELECT SERVERPROPERTY('SqlCharSetName')"
         end
-        
-        
+
+
         protected
-        
+
         def select(sql, name = nil, binds = [])
           exec_query(sql, name, binds).to_a
         end
-        
+
         def sql_for_insert(sql, pk, id_value, sequence_name, binds)
           sql = "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"# unless binds.empty?
           super
@@ -214,24 +313,23 @@ module ActiveRecord
         def last_inserted_id(result)
           super || select_value("SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident")
         end
-        
+
         # === SQLServer Specific ======================================== #
-        
+
         def valid_isolation_levels
           ["READ COMMITTED", "READ UNCOMMITTED", "REPEATABLE READ", "SERIALIZABLE", "SNAPSHOT"]
         end
-        
+
         # === SQLServer Specific (Executing) ============================ #
 
-        def do_execute(sql, name = nil)
-          name ||= 'EXECUTE'
+        def do_execute(sql, name = 'SQL')
           log(sql, name) do
-            with_auto_reconnect { raw_connection_do(sql) }
+            with_sqlserver_error_handling { raw_connection_do(sql) }
           end
         end
-        
+
         def do_exec_query(sql, name, binds)
-          statement = quote(sql)
+          explaining = name == 'EXPLAIN'
           names_and_types = []
           params = []
           binds.each_with_index do |(column,value),index|
@@ -250,13 +348,20 @@ module ActiveRecord
                                  raise "Unknown bind columns. We can account for this."
                                end
             quoted_value = ar_column ? quote(v,column) : quote(v,nil)
-            params << "@#{index} = #{quoted_value}"
+            params << (explaining ? quoted_value : "@#{index} = #{quoted_value}")
+          end
+          if explaining
+            params.each_with_index do |param, index|
+              substitute_at_finder = /(@#{index})(?=(?:[^']|'[^']*')*$)/ # Finds unquoted @n values.
+              sql.sub! substitute_at_finder, param
+            end
+          else
+            sql = "EXEC sp_executesql #{quote(sql)}"
+            sql << ", #{quote(names_and_types.join(', '))}, #{params.join(', ')}" unless binds.empty?
           end
-          sql = "EXEC sp_executesql #{statement}"
-          sql << ", #{quote(names_and_types.join(', '))}, #{params.join(', ')}" unless binds.empty?
           raw_select sql, name, binds, :ar_result => true
         end
-        
+
         def raw_connection_do(sql)
           case @connection_options[:mode]
           when :dblib
@@ -267,22 +372,24 @@ module ActiveRecord
         ensure
           @update_sql = false
         end
-        
+
         # === 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
+        def raw_select(sql, name='SQL', binds=[], options={})
+          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)
@@ -291,7 +398,7 @@ module ActiveRecord
             end
           end
         end
-        
+
         def handle_more_results?(handle)
           case @connection_options[:mode]
           when :dblib
@@ -299,7 +406,7 @@ module ActiveRecord
             handle.more_results
           end
         end
-        
+
         def handle_to_names_and_values(handle, options={})
           case @connection_options[:mode]
           when :dblib
@@ -308,7 +415,7 @@ module ActiveRecord
             handle_to_names_and_values_odbc(handle, options)
           end
         end
-        
+
         def handle_to_names_and_values_dblib(handle, options={})
           query_options = {}.tap do |qo|
             qo[:timezone] = ActiveRecord::Base.default_timezone || :utc
@@ -318,7 +425,7 @@ module ActiveRecord
           columns = lowercase_schema_reflection ? handle.fields.map { |c| c.downcase } : handle.fields
           options[:ar_result] ? ActiveRecord::Result.new(columns, results) : results
         end
-        
+
         def handle_to_names_and_values_odbc(handle, options={})
           @connection.use_utc = ActiveRecord::Base.default_timezone == :utc
           if options[:ar_result]
@@ -334,16 +441,17 @@ module ActiveRecord
             end
           end
         end
-        
+
         def finish_statement_handle(handle)
           case @connection_options[:mode]
-          when :dblib  
+          when :dblib
+            handle.cancel if handle
           when :odbc
             handle.drop if handle && handle.respond_to?(:drop) && !handle.finished?
           end
           handle
         end
-        
+
       end
     end
   end

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/quoting.rb

@@ -10,7 +10,7 @@ module ActiveRecord
           case value
           when String, ActiveSupport::Multibyte::Chars
             if column && column.type == :integer && value.blank?
-              nil
+              value.to_i.to_s
             elsif column && column.type == :binary
               column.class.string_to_binary(value)
             elsif value.is_utf8? || (column && column.type == :string)
@@ -42,8 +42,7 @@ module ActiveRecord
         end
 
         def quote_column_name(name)
-          @sqlserver_quoted_column_and_table_names[name] ||= 
-            name.to_s.split('.').map{ |n| n =~ /^\[.*\]$/ ? n : "[#{n.to_s.gsub(']', ']]')}]" }.join('.')
+          schema_cache.quote_name(name)
         end
 
         def quote_table_name(name)
@@ -68,7 +67,16 @@ module ActiveRecord
 
         def quoted_datetime(value)
           if value.acts_like?(:time)
-            value.is_a?(Date) ? quoted_value_acts_like_time_filter(value).to_time.xmlschema.to(18) : quoted_value_acts_like_time_filter(value).iso8601(3).to(22)
+            time_zone_qualified_value = quoted_value_acts_like_time_filter(value)
+            if value.is_a?(Date)
+              time_zone_qualified_value.to_time.xmlschema.to(18)
+            else
+              # CHANGED [Ruby 1.8] Not needed when 1.8 is dropped.
+              if value.is_a?(ActiveSupport::TimeWithZone) && RUBY_VERSION < '1.9'
+                time_zone_qualified_value = time_zone_qualified_value.to_time 
+              end
+              time_zone_qualified_value.iso8601(3).to(22)
+            end
           else
             quoted_date(value)
           end

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

@@ -0,0 +1,85 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sqlserver
+      class SchemaCache < ActiveRecord::ConnectionAdapters::SchemaCache
+        
+        attr_reader :view_information
+        
+        def initialize(conn)
+          super
+          @table_names = nil
+          @view_names = nil
+          @view_information = {}
+          @quoted_names = {}
+        end
+        
+        # Superclass Overrides
+        
+        def table_exists?(table_name)
+          return false if table_name.blank?
+          key = table_name_key(table_name)
+          return @tables[key] if @tables.key? key
+          @tables[key] = connection.table_exists?(table_name)
+        end
+        
+        def clear!
+          super
+          @table_names = nil
+          @view_names = nil
+          @view_information.clear
+          @quoted_names.clear
+        end
+        
+        def clear_table_cache!(table_name)
+          key = table_name_key(table_name)
+          super(key)
+          super(table_name)
+          # SQL Server Specific
+          if @table_names
+            @table_names.delete key
+            @table_names.delete table_name
+          end
+          if @view_names
+            @view_names.delete key
+            @view_names.delete table_name
+          end
+          @view_information.delete key
+        end
+        
+        # SQL Server Specific
+        
+        def table_names
+          @table_names ||= connection.tables
+        end
+        
+        def view_names
+          @view_names ||= connection.views
+        end
+        
+        def view_exists?(table_name)
+          table_exists?(table_name)
+        end
+        
+        def view_information(table_name)
+          key = table_name_key(table_name)
+          return @view_information[key] if @view_information.key? key
+          @view_information[key] = connection.send(:view_information, table_name)
+        end
+        
+        def quote_name(name)
+          return @quoted_names[name] if @quoted_names.key? name
+          @quoted_names[name] = name.to_s.split('.').map{ |n| n =~ /^\[.*\]$/ ? n : "[#{n.to_s.gsub(']', ']]')}]" }.join('.')
+        end
+        
+        
+        private
+        
+        def table_name_key(table_name)
+          Utils.unqualify_table_name(table_name)
+        end
+        
+      end
+    end
+  end
+end
+